diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn index 9a78107b26..6e379fdc56 100644 --- a/src/tint/BUILD.gn +++ b/src/tint/BUILD.gn @@ -367,6 +367,8 @@ libtint_source_set("libtint_core_all_src") { "program_id.h", "reader/reader.cc", "reader/reader.h", + "resolver/ctor_conv_intrinsic.cc", + "resolver/ctor_conv_intrinsic.h", "resolver/dependency_graph.cc", "resolver/dependency_graph.h", "resolver/intrinsic_table.cc", diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt index d49259538d..6691c8654c 100644 --- a/src/tint/CMakeLists.txt +++ b/src/tint/CMakeLists.txt @@ -248,6 +248,8 @@ set(TINT_LIB_SRCS program.h reader/reader.cc reader/reader.h + resolver/ctor_conv_intrinsic.cc + resolver/ctor_conv_intrinsic.h resolver/dependency_graph.cc resolver/dependency_graph.h resolver/intrinsic_table.cc diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def index 0bebe4b7c6..15f714f349 100644 --- a/src/tint/intrinsics.def +++ b/src/tint/intrinsics.def @@ -72,6 +72,15 @@ type u32 type vec2 type vec3 type vec4 +type mat2x2 +type mat2x3 +type mat2x4 +type mat3x2 +type mat3x3 +type mat3x4 +type mat4x2 +type mat4x3 +type mat4x4 [[display("vec{N}<{T}>")]] type vec [[display("mat{N}x{M}<{T}>")]] type mat type ptr @@ -112,6 +121,10 @@ match fiu32: f32 | i32 | u32 match fi32: f32 | i32 match iu32: i32 | u32 match scalar: f32 | i32 | u32 | bool +match scalar_no_f32: i32 | u32 | bool +match scalar_no_i32: f32 | u32 | bool +match scalar_no_u32: f32 | i32 | bool +match scalar_no_bool: f32 | i32 | u32 //////////////////////////////////////////////////////////////////////////////// // Enum matchers // @@ -562,6 +575,122 @@ fn textureLoad(texture: texture_external, coords: vec2) -> vec4 [[stage("fragment", "compute")]] fn atomicExchange(ptr, read_write>, T) -> T [[stage("fragment", "compute")]] fn atomicCompareExchangeWeak(ptr, read_write>, T, T) -> vec2 +//////////////////////////////////////////////////////////////////////////////// +// Type constructors // +//////////////////////////////////////////////////////////////////////////////// + +// Zero value constructors +ctor i32() -> i32 +ctor u32() -> u32 +ctor f32() -> f32 +ctor bool() -> bool +ctor vec2() -> vec2 +ctor vec3() -> vec3 +ctor vec4() -> vec4 +ctor mat2x2() -> mat2x2 +ctor mat2x3() -> mat2x3 +ctor mat2x4() -> mat2x4 +ctor mat3x2() -> mat3x2 +ctor mat3x3() -> mat3x3 +ctor mat3x4() -> mat3x4 +ctor mat4x2() -> mat4x2 +ctor mat4x3() -> mat4x3 +ctor mat4x4() -> mat4x4 + +// Identity constructors +ctor i32(i32) -> i32 +ctor u32(u32) -> u32 +ctor f32(f32) -> f32 +ctor bool(bool) -> bool +ctor vec2(vec2) -> vec2 +ctor vec3(vec3) -> vec3 +ctor vec4(vec4) -> vec4 + +// Vector constructors +ctor vec2(T) -> vec2 +ctor vec2(x: T, y: T) -> vec2 +ctor vec3(T) -> vec3 +ctor vec3(x: T, y: T, z: T) -> vec3 +ctor vec3(xy: vec2, z: T) -> vec3 +ctor vec3(x: T, yz: vec2) -> vec3 +ctor vec4(T) -> vec4 +ctor vec4(x: T, y: T, z: T, w: T) -> vec4 +ctor vec4(xy: vec2, z: T, w: T) -> vec4 +ctor vec4(x: T, yz: vec2, w: T) -> vec4 +ctor vec4(x: T, y: T, zw: vec2) -> vec4 +ctor vec4(xy: vec2, zw: vec2) -> vec4 +ctor vec4(xyz: vec3, w: T) -> vec4 +ctor vec4(x: T, zyw: vec3) -> vec4 + +// Matrix constructors +ctor mat2x2(f32, f32, + f32, f32) -> mat2x2 +ctor mat2x2(vec2, vec2) -> mat2x2 + +ctor mat2x3(f32, f32, f32, + f32, f32, f32) -> mat2x3 +ctor mat2x3(vec3, vec3) -> mat2x3 + +ctor mat2x4(f32, f32, f32, f32, + f32, f32, f32, f32) -> mat2x4 +ctor mat2x4(vec4, vec4) -> mat2x4 + +ctor mat3x2(f32, f32, + f32, f32, + f32, f32) -> mat3x2 +ctor mat3x2(vec2, vec2, vec2) -> mat3x2 + +ctor mat3x3(f32, f32, f32, + f32, f32, f32, + f32, f32, f32) -> mat3x3 +ctor mat3x3(vec3, vec3, vec3) -> mat3x3 + +ctor mat3x4(f32, f32, f32, f32, + f32, f32, f32, f32, + f32, f32, f32, f32) -> mat3x4 +ctor mat3x4(vec4, vec4, vec4) -> mat3x4 + +ctor mat4x2(f32, f32, + f32, f32, + f32, f32, + f32, f32) -> mat4x2 +ctor mat4x2(vec2, vec2, vec2, vec2) -> mat4x2 + +ctor mat4x3(f32, f32, f32, + f32, f32, f32, + f32, f32, f32, + f32, f32, f32) -> mat4x3 +ctor mat4x3(vec3, vec3, vec3, vec3) -> mat4x3 + +ctor mat4x4(f32, f32, f32, f32, + f32, f32, f32, f32, + f32, f32, f32, f32, + f32, f32, f32, f32) -> mat4x4 +ctor mat4x4(vec4, vec4, vec4, vec4) -> mat4x4 + +//////////////////////////////////////////////////////////////////////////////// +// Type conversions // +//////////////////////////////////////////////////////////////////////////////// +conv f32(T) -> f32 +conv i32(T) -> i32 +conv u32(T) -> u32 +conv bool(T) -> bool + +conv vec2(vec2) -> vec2 +conv vec2(vec2) -> vec2 +conv vec2(vec2) -> vec2 +conv vec2(vec2) -> vec2 + +conv vec3(vec3) -> vec3 +conv vec3(vec3) -> vec3 +conv vec3(vec3) -> vec3 +conv vec3(vec3) -> vec3 + +conv vec4(vec4) -> vec4 +conv vec4(vec4) -> vec4 +conv vec4(vec4) -> vec4 +conv vec4(vec4) -> vec4 + //////////////////////////////////////////////////////////////////////////////// // Operators // // // diff --git a/src/tint/resolver/ctor_conv_intrinsic.cc b/src/tint/resolver/ctor_conv_intrinsic.cc new file mode 100644 index 0000000000..5618fbab49 --- /dev/null +++ b/src/tint/resolver/ctor_conv_intrinsic.cc @@ -0,0 +1,70 @@ +// 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/tint/resolver/ctor_conv_intrinsic.cc.tmpl +// and the intrinsic defintion file: +// src/tint/intrinsics.def +// +// Do not modify this file directly +//////////////////////////////////////////////////////////////////////////////// + +#include "src/tint/resolver/ctor_conv_intrinsic.h" + +namespace tint::resolver { + +const char* str(CtorConvIntrinsic i) { + switch (i) { + case CtorConvIntrinsic::kNone: + return ""; + case CtorConvIntrinsic::kI32: + return "i32"; + case CtorConvIntrinsic::kU32: + return "u32"; + case CtorConvIntrinsic::kF32: + return "f32"; + case CtorConvIntrinsic::kBool: + return "bool"; + case CtorConvIntrinsic::kVec2: + return "vec2"; + case CtorConvIntrinsic::kVec3: + return "vec3"; + case CtorConvIntrinsic::kVec4: + return "vec4"; + case CtorConvIntrinsic::kMat2x2: + return "mat2x2"; + case CtorConvIntrinsic::kMat2x3: + return "mat2x3"; + case CtorConvIntrinsic::kMat2x4: + return "mat2x4"; + case CtorConvIntrinsic::kMat3x2: + return "mat3x2"; + case CtorConvIntrinsic::kMat3x3: + return "mat3x3"; + case CtorConvIntrinsic::kMat3x4: + return "mat3x4"; + case CtorConvIntrinsic::kMat4x2: + return "mat4x2"; + case CtorConvIntrinsic::kMat4x3: + return "mat4x3"; + case CtorConvIntrinsic::kMat4x4: + return "mat4x4"; + } + return ""; +} + +} // namespace tint::resolver + diff --git a/src/tint/resolver/ctor_conv_intrinsic.cc.tmpl b/src/tint/resolver/ctor_conv_intrinsic.cc.tmpl new file mode 100644 index 0000000000..ac98c4d22e --- /dev/null +++ b/src/tint/resolver/ctor_conv_intrinsic.cc.tmpl @@ -0,0 +1,28 @@ +{{- /* +-------------------------------------------------------------------------------- +Template file for use with tools/builtin-gen to generate ctor_conv_intrinsic.cc + +See: +* tools/cmd/intrinsic-gen/gen for structures used by this template +* https://golang.org/pkg/text/template/ for documentation on the template syntax +-------------------------------------------------------------------------------- +*/ -}} + +#include "src/tint/resolver/ctor_conv_intrinsic.h" + +namespace tint::resolver { + +const char* str(CtorConvIntrinsic i) { + switch (i) { + case CtorConvIntrinsic::kNone: + return ""; +{{- range .Sem.ConstructorsAndConverters }} + case CtorConvIntrinsic::k{{Title .Name}}: + return "{{.Name}}"; +{{- end }} + } + return ""; +} + +} // namespace tint::resolver + diff --git a/src/tint/resolver/ctor_conv_intrinsic.h b/src/tint/resolver/ctor_conv_intrinsic.h new file mode 100644 index 0000000000..7c68658303 --- /dev/null +++ b/src/tint/resolver/ctor_conv_intrinsic.h @@ -0,0 +1,100 @@ +// 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/tint/resolver/ctor_conv_intrinsic.h.tmpl +// and the intrinsic defintion file: +// src/tint/intrinsics.def +// +// Do not modify this file directly +//////////////////////////////////////////////////////////////////////////////// + +#ifndef SRC_TINT_RESOLVER_CTOR_CONV_INTRINSIC_H_ +#define SRC_TINT_RESOLVER_CTOR_CONV_INTRINSIC_H_ + +#include + +namespace tint::resolver { + +/// CtorConvIntrinsic is an enumerator of types that have a constructor or converter overload +/// declared in the intrinsic table. +enum class CtorConvIntrinsic { + kNone = -1, + kI32, + kU32, + kF32, + kBool, + kVec2, + kVec3, + kVec4, + kMat2x2, + kMat2x3, + kMat2x4, + kMat3x2, + kMat3x3, + kMat3x4, + kMat4x2, + kMat4x3, + kMat4x4, +}; + +/// @returns the name of the type. +const char* str(CtorConvIntrinsic i); + +/// @param n the width of the vector +/// @return the CtorConvIntrinsic for a vector of width `n` +inline CtorConvIntrinsic VectorCtorConvIntrinsic(uint32_t n) { + switch (n) { + case 2: + return CtorConvIntrinsic::kVec2; + case 3: + return CtorConvIntrinsic::kVec3; + case 4: + return CtorConvIntrinsic::kVec4; + } + return CtorConvIntrinsic::kNone; +} + +/// @param c the number of columns in the matrix +/// @param r the number of rows in the matrix +/// @return the CtorConvIntrinsic for a matrix with `c` columns and `r` rows +inline CtorConvIntrinsic MatrixCtorConvIntrinsic(uint32_t c, uint32_t r) { + switch ((c - 2) * 3 + (r - 2)) { + case 0: + return CtorConvIntrinsic::kMat2x2; + case 1: + return CtorConvIntrinsic::kMat2x3; + case 2: + return CtorConvIntrinsic::kMat2x4; + case 3: + return CtorConvIntrinsic::kMat3x2; + case 4: + return CtorConvIntrinsic::kMat3x3; + case 5: + return CtorConvIntrinsic::kMat3x4; + case 6: + return CtorConvIntrinsic::kMat4x2; + case 7: + return CtorConvIntrinsic::kMat4x3; + case 8: + return CtorConvIntrinsic::kMat4x4; + } + return CtorConvIntrinsic::kNone; +} + +} // namespace tint::resolver + +#endif // SRC_TINT_RESOLVER_CTOR_CONV_INTRINSIC_H_ diff --git a/src/tint/resolver/ctor_conv_intrinsic.h.tmpl b/src/tint/resolver/ctor_conv_intrinsic.h.tmpl new file mode 100644 index 0000000000..9c0da25805 --- /dev/null +++ b/src/tint/resolver/ctor_conv_intrinsic.h.tmpl @@ -0,0 +1,73 @@ +{{- /* +-------------------------------------------------------------------------------- +Template file for use with tools/builtin-gen to generate ctor_conv_intrinsic.h + +See: +* tools/cmd/intrinsic-gen/gen for structures used by this template +* https://golang.org/pkg/text/template/ for documentation on the template syntax +-------------------------------------------------------------------------------- +*/ -}} + +#ifndef SRC_TINT_RESOLVER_CTOR_CONV_INTRINSIC_H_ +#define SRC_TINT_RESOLVER_CTOR_CONV_INTRINSIC_H_ + +#include + +namespace tint::resolver { + +/// CtorConvIntrinsic is an enumerator of types that have a constructor or converter overload +/// declared in the intrinsic table. +enum class CtorConvIntrinsic { + kNone = -1, +{{- range .Sem.ConstructorsAndConverters }} + k{{Title .Name}}, +{{- end }} +}; + +/// @returns the name of the type. +const char* str(CtorConvIntrinsic i); + +/// @param n the width of the vector +/// @return the CtorConvIntrinsic for a vector of width `n` +inline CtorConvIntrinsic VectorCtorConvIntrinsic(uint32_t n) { + switch (n) { + case 2: + return CtorConvIntrinsic::kVec2; + case 3: + return CtorConvIntrinsic::kVec3; + case 4: + return CtorConvIntrinsic::kVec4; + } + return CtorConvIntrinsic::kNone; +} + +/// @param c the number of columns in the matrix +/// @param r the number of rows in the matrix +/// @return the CtorConvIntrinsic for a matrix with `c` columns and `r` rows +inline CtorConvIntrinsic MatrixCtorConvIntrinsic(uint32_t c, uint32_t r) { + switch ((c - 2) * 3 + (r - 2)) { + case 0: + return CtorConvIntrinsic::kMat2x2; + case 1: + return CtorConvIntrinsic::kMat2x3; + case 2: + return CtorConvIntrinsic::kMat2x4; + case 3: + return CtorConvIntrinsic::kMat3x2; + case 4: + return CtorConvIntrinsic::kMat3x3; + case 5: + return CtorConvIntrinsic::kMat3x4; + case 6: + return CtorConvIntrinsic::kMat4x2; + case 7: + return CtorConvIntrinsic::kMat4x3; + case 8: + return CtorConvIntrinsic::kMat4x4; + } + return CtorConvIntrinsic::kNone; +} + +} // namespace tint::resolver + +#endif // SRC_TINT_RESOLVER_CTOR_CONV_INTRINSIC_H_ diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc index e32dc78d01..5ca8ee2109 100644 --- a/src/tint/resolver/intrinsic_table.cc +++ b/src/tint/resolver/intrinsic_table.cc @@ -28,6 +28,8 @@ #include "src/tint/sem/pipeline_stage_set.h" #include "src/tint/sem/sampled_texture.h" #include "src/tint/sem/storage_texture.h" +#include "src/tint/sem/type_constructor.h" +#include "src/tint/sem/type_conversion.h" #include "src/tint/utils/hash.h" #include "src/tint/utils/map.h" #include "src/tint/utils/math.h" @@ -120,17 +122,10 @@ class ClosedState { return res.second || res.first->second == number.Value(); } - /// Type returns the closed type with index `idx`. - /// An ICE is raised if the type is not closed. + /// Type returns the closed type with index `idx`, or nullptr if the type was not closed. const sem::Type* Type(uint32_t idx) const { auto it = types_.find(idx); - if (it == types_.end()) { - TINT_ICE(Resolver, builder.Diagnostics()) - << "type with index " << idx << " is not closed"; - return nullptr; - } - TINT_ASSERT(Resolver, it != types_.end()); - return it->second; + return (it != types_.end()) ? it->second : nullptr; } /// Type returns the number type with index `idx`. @@ -295,6 +290,8 @@ using PipelineStage = ast::PipelineStage; enum class OverloadFlag { kIsBuiltin, // The overload is a builtin ('fn') kIsOperator, // The overload is an operator ('op') + kIsConstructor, // The overload is a type constructor ('ctor') + kIsConverter, // The overload is a type converter ('conv') kSupportsVertexPipeline, // The overload can be used in vertex shaders kSupportsFragmentPipeline, // The overload can be used in fragment shaders kSupportsComputePipeline, // The overload can be used in compute shaders @@ -351,11 +348,7 @@ bool match_vec(const sem::Type* ty, Number& N, const sem::Type*& T) { return false; } -const sem::Vector* build_vec(MatchState& state, Number N, const sem::Type* el) { - return state.builder.create(el, N.Value()); -} - -template +template bool match_vec(const sem::Type* ty, const sem::Type*& T) { if (ty->Is()) { T = ty; @@ -371,29 +364,22 @@ bool match_vec(const sem::Type* ty, const sem::Type*& T) { return false; } -bool match_vec2(const sem::Type* ty, const sem::Type*& T) { - return match_vec<2>(ty, T); +const sem::Vector* build_vec(MatchState& state, Number N, const sem::Type* el) { + return state.builder.create(el, N.Value()); } -const sem::Vector* build_vec2(MatchState& state, const sem::Type* T) { - return build_vec(state, Number(2), T); +template +const sem::Vector* build_vec(MatchState& state, const sem::Type* el) { + return state.builder.create(el, N); } -bool match_vec3(const sem::Type* ty, const sem::Type*& T) { - return match_vec<3>(ty, T); -} +constexpr auto match_vec2 = match_vec<2>; +constexpr auto match_vec3 = match_vec<3>; +constexpr auto match_vec4 = match_vec<4>; -const sem::Vector* build_vec3(MatchState& state, const sem::Type* T) { - return build_vec(state, Number(3), T); -} - -bool match_vec4(const sem::Type* ty, const sem::Type*& T) { - return match_vec<4>(ty, T); -} - -const sem::Vector* build_vec4(MatchState& state, const sem::Type* T) { - return build_vec(state, Number(4), T); -} +constexpr auto build_vec2 = build_vec<2>; +constexpr auto build_vec3 = build_vec<3>; +constexpr auto build_vec4 = build_vec<4>; bool match_mat(const sem::Type* ty, Number& M, Number& N, const sem::Type*& T) { if (ty->Is()) { @@ -411,11 +397,52 @@ bool match_mat(const sem::Type* ty, Number& M, Number& N, const sem::Type*& T) { return false; } -const sem::Matrix* build_mat(MatchState& state, Number N, Number M, const sem::Type* T) { - auto* column_type = state.builder.create(T, M.Value()); - return state.builder.create(column_type, N.Value()); +template +bool match_mat(const sem::Type* ty, const sem::Type*& T) { + if (ty->Is()) { + T = ty; + return true; + } + if (auto* m = ty->As()) { + if (m->columns() == C && m->rows() == R) { + T = m->type(); + return true; + } + } + return false; } +const sem::Matrix* build_mat(MatchState& state, Number C, Number R, const sem::Type* T) { + auto* column_type = state.builder.create(T, R.Value()); + return state.builder.create(column_type, C.Value()); +} + +template +const sem::Matrix* build_mat(MatchState& state, const sem::Type* T) { + auto* column_type = state.builder.create(T, R); + return state.builder.create(column_type, C); +} + +constexpr auto build_mat2x2 = build_mat<2, 2>; +constexpr auto build_mat2x3 = build_mat<2, 3>; +constexpr auto build_mat2x4 = build_mat<2, 4>; +constexpr auto build_mat3x2 = build_mat<3, 2>; +constexpr auto build_mat3x3 = build_mat<3, 3>; +constexpr auto build_mat3x4 = build_mat<3, 4>; +constexpr auto build_mat4x2 = build_mat<4, 2>; +constexpr auto build_mat4x3 = build_mat<4, 3>; +constexpr auto build_mat4x4 = build_mat<4, 4>; + +constexpr auto match_mat2x2 = match_mat<2, 2>; +constexpr auto match_mat2x3 = match_mat<2, 3>; +constexpr auto match_mat2x4 = match_mat<2, 4>; +constexpr auto match_mat3x2 = match_mat<3, 2>; +constexpr auto match_mat3x3 = match_mat<3, 3>; +constexpr auto match_mat3x4 = match_mat<3, 4>; +constexpr auto match_mat4x2 = match_mat<4, 2>; +constexpr auto match_mat4x3 = match_mat<4, 3>; +constexpr auto match_mat4x4 = match_mat<4, 4>; + bool match_array(const sem::Type* ty, const sem::Type*& T) { if (ty->Is()) { T = ty; @@ -843,37 +870,108 @@ class Impl : public IntrinsicTable { const Source& source, bool is_compound) override; + const sem::CallTarget* Lookup(CtorConvIntrinsic type, + const sem::Type* template_arg, + const std::vector& args, + const Source& source) override; + private: - // Candidate holds information about a mismatched overload that could be what the user intended - // to call. + /// Candidate holds information about an overload evaluated for resolution. struct Candidate { - const OverloadInfo* overload; + /// The candidate overload + const OverloadInfo& overload; + /// The closed types and numbers + ClosedState closed; + /// The parameter types for the candidate overload + std::vector parameters; + /// True if the candidate is a viable match for the call + bool matched; + /// The match-score of the candidate overload. Used for diagnostics when no overload + /// matches. Higher scores are displayed first (top-most). int score; }; - const IntrinsicPrototype Match(const char* intrinsic_name, - const OverloadInfo& overload, - const std::vector& args, - int& match_score); + /// A list of candidates + using Candidates = std::vector; + /// Callback function when no overloads match. + using OnNoMatch = std::function; + + /// Attempts to find a single intrinsic overload that matches the provided argument types. + /// @param intrinsic the intrinsic being called + /// @param intrinsic_name the name of the intrinsic + /// @param args the argument types + /// @param closed initial closed state. This may contain explicitly specified template + /// arguments. For example `vec3()` would have the first template-type closed + /// as `f32`. + /// @param on_no_match an error callback when no intrinsic overloads matched the provided + /// arguments. + /// @returns the matched intrinsic. If no intrinsic could be matched then IntrinsicPrototype + /// will hold nullptrs for IntrinsicPrototype::overload and + /// IntrinsicPrototype::return_type. + IntrinsicPrototype MatchIntrinsic(const IntrinsicInfo& intrinsic, + const char* intrinsic_name, + const std::vector& args, + ClosedState closed, + OnNoMatch on_no_match) const; + + /// Evaluates the overload for the provided argument types. + /// @param overload the overload being considered + /// @param args the argument types + /// @param closed initial closed state. This may contain explicitly specified template + /// arguments. For example `vec3()` would have the first template-type closed + /// as `f32`. + /// @returns the evaluated Candidate information. + Candidate ScoreOverload(const OverloadInfo& overload, + const std::vector& args, + ClosedState closed) const; + + /// Match constructs a new MatchState + /// @param closed the open / closed numbers and types used for matcher evaluation + /// @param overload the overload being evaluated + /// @param matcher_indices pointer to a list of matcher indices MatchState Match(ClosedState& closed, const OverloadInfo& overload, MatcherIndex const* matcher_indices) const; - void PrintOverload(std::ostream& ss, const OverloadInfo& overload, const char* name) const; + // Prints the overload for emitting diagnostics + void PrintOverload(std::ostream& ss, + const OverloadInfo& overload, + const char* intrinsic_name) const; + + // Prints the list of candidates for emitting diagnostics + void PrintCandidates(std::ostream& ss, + const Candidates& candidates, + const char* intrinsic_name) const; + + /// Raises an ICE when multiple overload candidates match, as this should never happen. + void ErrMultipleOverloadsMatched(uint32_t num_matched, + const char* intrinsic_name, + const std::vector& args, + ClosedState closed, + Candidates candidates) const; ProgramBuilder& builder; Matchers matchers; std::unordered_map builtins; + std::unordered_map + constructors; + std::unordered_map + converters; }; /// @return a string representing a call to a builtin with the given argument /// types. std::string CallSignature(ProgramBuilder& builder, const char* intrinsic_name, - const std::vector& args) { + const std::vector& args, + const sem::Type* template_arg = nullptr) { std::stringstream ss; - ss << intrinsic_name << "("; + ss << intrinsic_name; + if (template_arg) { + ss << "<" << template_arg->FriendlyName(builder.Symbols()) << ">"; + } + ss << "("; { bool first = true; for (auto* arg : args) { @@ -902,73 +1000,56 @@ Impl::Impl(ProgramBuilder& b) : builder(b) {} const sem::Builtin* Impl::Lookup(sem::BuiltinType builtin_type, const std::vector& args, const Source& source) { - // The list of failed matches that had promise. - std::vector candidates; - - uint32_t intrinsic_index = static_cast(builtin_type); const char* intrinsic_name = sem::str(builtin_type); - auto& builtin = kBuiltins[intrinsic_index]; - for (uint32_t o = 0; o < builtin.num_overloads; o++) { - int match_score = 1000; - auto& overload = builtin.overloads[o]; - auto match = Match(intrinsic_name, overload, args, match_score); - if (match.return_type) { - // De-duplicate builtins that are identical. - return utils::GetOrCreate(builtins, match, [&] { - std::vector params; - params.reserve(match.parameters.size()); - for (auto& p : match.parameters) { - params.emplace_back(builder.create( - nullptr, static_cast(params.size()), p.type, - ast::StorageClass::kNone, ast::Access::kUndefined, p.usage)); - } - sem::PipelineStageSet supported_stages; - if (match.overload->flags.Contains(OverloadFlag::kSupportsVertexPipeline)) { - supported_stages.Add(ast::PipelineStage::kVertex); - } - if (match.overload->flags.Contains(OverloadFlag::kSupportsFragmentPipeline)) { - supported_stages.Add(ast::PipelineStage::kFragment); - } - if (match.overload->flags.Contains(OverloadFlag::kSupportsComputePipeline)) { - supported_stages.Add(ast::PipelineStage::kCompute); - } - return builder.create( - builtin_type, match.return_type, std::move(params), supported_stages, - match.overload->flags.Contains(OverloadFlag::kIsDeprecated)); - }); - } - if (match_score > 0) { - candidates.emplace_back(Candidate{&overload, match_score}); + + // Generates an error when no overloads match the provided arguments + auto on_no_match = [&](Candidates candidates) { + std::stringstream ss; + ss << "no matching call to " << CallSignature(builder, intrinsic_name, args) << std::endl; + if (!candidates.empty()) { + ss << std::endl + << candidates.size() << " candidate function" << (candidates.size() > 1 ? "s:" : ":") + << std::endl; + PrintCandidates(ss, candidates, intrinsic_name); } + builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); + }; + + // Resolve the intrinsic overload + auto match = MatchIntrinsic(kBuiltins[static_cast(builtin_type)], intrinsic_name, + args, ClosedState(builder), on_no_match); + if (!match.overload) { + return {}; } - // Sort the candidates with the most promising first - std::stable_sort(candidates.begin(), candidates.end(), - [](const Candidate& a, const Candidate& b) { return a.score > b.score; }); - - // Generate an error message - std::stringstream ss; - ss << "no matching call to " << CallSignature(builder, intrinsic_name, args) << std::endl; - if (!candidates.empty()) { - ss << std::endl; - ss << candidates.size() << " candidate function" << (candidates.size() > 1 ? "s:" : ":") - << std::endl; - for (auto& candidate : candidates) { - ss << " "; - PrintOverload(ss, *candidate.overload, intrinsic_name); - ss << std::endl; + // De-duplicate builtins that are identical. + return utils::GetOrCreate(builtins, match, [&] { + std::vector params; + params.reserve(match.parameters.size()); + for (auto& p : match.parameters) { + params.emplace_back(builder.create( + nullptr, static_cast(params.size()), p.type, ast::StorageClass::kNone, + ast::Access::kUndefined, p.usage)); } - } - builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); - return nullptr; + sem::PipelineStageSet supported_stages; + if (match.overload->flags.Contains(OverloadFlag::kSupportsVertexPipeline)) { + supported_stages.Add(ast::PipelineStage::kVertex); + } + if (match.overload->flags.Contains(OverloadFlag::kSupportsFragmentPipeline)) { + supported_stages.Add(ast::PipelineStage::kFragment); + } + if (match.overload->flags.Contains(OverloadFlag::kSupportsComputePipeline)) { + supported_stages.Add(ast::PipelineStage::kCompute); + } + return builder.create( + builtin_type, match.return_type, std::move(params), supported_stages, + match.overload->flags.Contains(OverloadFlag::kIsDeprecated)); + }); } IntrinsicTable::UnaryOperator Impl::Lookup(ast::UnaryOp op, const sem::Type* arg, const Source& source) { - // The list of failed matches that had promise. - std::vector candidates; - auto [intrinsic_index, intrinsic_name] = [&]() -> std::pair { switch (op) { case ast::UnaryOp::kComplement: @@ -982,38 +1063,27 @@ IntrinsicTable::UnaryOperator Impl::Lookup(ast::UnaryOp op, } }(); - auto& builtin = kUnaryOperators[intrinsic_index]; - for (uint32_t o = 0; o < builtin.num_overloads; o++) { - int match_score = 1000; - auto& overload = builtin.overloads[o]; - auto match = Match(intrinsic_name, overload, {arg}, match_score); - if (match.return_type) { - return UnaryOperator{match.return_type, match.parameters[0].type}; - } - if (match_score > 0) { - candidates.emplace_back(Candidate{&overload, match_score}); + // Generates an error when no overloads match the provided arguments + auto on_no_match = [&, name = intrinsic_name](Candidates candidates) { + std::stringstream ss; + ss << "no matching overload for " << CallSignature(builder, name, {arg}) << std::endl; + if (!candidates.empty()) { + ss << std::endl + << candidates.size() << " candidate operator" << (candidates.size() > 1 ? "s:" : ":") + << std::endl; + PrintCandidates(ss, candidates, name); } + builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); + }; + + // Resolve the intrinsic overload + auto match = MatchIntrinsic(kUnaryOperators[intrinsic_index], intrinsic_name, {arg}, + ClosedState(builder), on_no_match); + if (!match.overload) { + return {}; } - // Sort the candidates with the most promising first - std::stable_sort(candidates.begin(), candidates.end(), - [](const Candidate& a, const Candidate& b) { return a.score > b.score; }); - - // Generate an error message - std::stringstream ss; - ss << "no matching overload for " << CallSignature(builder, intrinsic_name, {arg}) << std::endl; - if (!candidates.empty()) { - ss << std::endl; - ss << candidates.size() << " candidate operator" << (candidates.size() > 1 ? "s:" : ":") - << std::endl; - for (auto& candidate : candidates) { - ss << " "; - PrintOverload(ss, *candidate.overload, intrinsic_name); - ss << std::endl; - } - } - builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); - return {}; + return UnaryOperator{match.return_type, match.parameters[0].type}; } IntrinsicTable::BinaryOperator Impl::Lookup(ast::BinaryOp op, @@ -1021,9 +1091,6 @@ IntrinsicTable::BinaryOperator Impl::Lookup(ast::BinaryOp op, const sem::Type* rhs, const Source& source, bool is_compound) { - // The list of failed matches that had promise. - std::vector candidates; - auto [intrinsic_index, intrinsic_name] = [&]() -> std::pair { switch (op) { case ast::BinaryOp::kAnd: @@ -1067,47 +1134,175 @@ IntrinsicTable::BinaryOperator Impl::Lookup(ast::BinaryOp op, } }(); - auto& builtin = kBinaryOperators[intrinsic_index]; - for (uint32_t o = 0; o < builtin.num_overloads; o++) { - int match_score = 1000; - auto& overload = builtin.overloads[o]; - auto match = Match(intrinsic_name, overload, {lhs, rhs}, match_score); - if (match.return_type) { - return BinaryOperator{match.return_type, match.parameters[0].type, - match.parameters[1].type}; + // Generates an error when no overloads match the provided arguments + auto on_no_match = [&, name = intrinsic_name](Candidates candidates) { + std::stringstream ss; + ss << "no matching overload for " << CallSignature(builder, name, {lhs, rhs}) << std::endl; + if (!candidates.empty()) { + ss << std::endl + << candidates.size() << " candidate operator" << (candidates.size() > 1 ? "s:" : ":") + << std::endl; + PrintCandidates(ss, candidates, name); } - if (match_score > 0) { - candidates.emplace_back(Candidate{&overload, match_score}); + builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); + }; + + // Resolve the intrinsic overload + auto match = MatchIntrinsic(kBinaryOperators[intrinsic_index], intrinsic_name, {lhs, rhs}, + ClosedState(builder), on_no_match); + if (!match.overload) { + return {}; + } + + return BinaryOperator{match.return_type, match.parameters[0].type, match.parameters[1].type}; +} + +const sem::CallTarget* Impl::Lookup(CtorConvIntrinsic type, + const sem::Type* template_arg, + const std::vector& args, + const Source& source) { + auto name = str(type); + + // Generates an error when no overloads match the provided arguments + auto on_no_match = [&](Candidates candidates) { + std::stringstream ss; + ss << "no matching constructor for " << CallSignature(builder, name, args, template_arg) + << std::endl; + Candidates ctor, conv; + for (auto candidate : candidates) { + if (candidate.overload.flags.Contains(OverloadFlag::kIsConstructor)) { + ctor.emplace_back(candidate); + } else { + conv.emplace_back(candidate); + } } + if (!ctor.empty()) { + ss << std::endl + << ctor.size() << " candidate constructor" << (ctor.size() > 1 ? "s:" : ":") + << std::endl; + PrintCandidates(ss, ctor, name); + } + if (!conv.empty()) { + ss << std::endl + << conv.size() << " candidate conversion" << (conv.size() > 1 ? "s:" : ":") + << std::endl; + PrintCandidates(ss, conv, name); + } + builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); + }; + + // If a template type was provided, then close the 0'th type with this. + ClosedState closed(builder); + if (template_arg) { + closed.Type(0, template_arg); + } + + // Resolve the intrinsic overload + auto match = MatchIntrinsic(kConstructorsAndConverters[static_cast(type)], name, args, + closed, on_no_match); + if (!match.overload) { + return {}; + } + + // Was this overload a constructor or conversion? + if (match.overload->flags.Contains(OverloadFlag::kIsConstructor)) { + sem::ParameterList params; + params.reserve(match.parameters.size()); + for (auto& p : match.parameters) { + params.emplace_back(builder.create( + nullptr, static_cast(params.size()), p.type, ast::StorageClass::kNone, + ast::Access::kUndefined, p.usage)); + } + return utils::GetOrCreate(constructors, match, [&]() { + return builder.create(match.return_type, std::move(params)); + }); + } + + // Conversion. + return utils::GetOrCreate(converters, match, [&]() { + auto param = builder.create( + nullptr, 0, match.parameters[0].type, ast::StorageClass::kNone, ast::Access::kUndefined, + match.parameters[0].usage); + return builder.create(match.return_type, param); + }); +} + +IntrinsicPrototype Impl::MatchIntrinsic(const IntrinsicInfo& intrinsic, + const char* intrinsic_name, + const std::vector& args, + ClosedState closed, + OnNoMatch on_no_match) const { + uint32_t num_matched = 0; + Candidates candidates; + candidates.reserve(intrinsic.num_overloads); + for (uint8_t overload_idx = 0; overload_idx < intrinsic.num_overloads; overload_idx++) { + auto candidate = ScoreOverload(intrinsic.overloads[overload_idx], args, closed); + if (candidate.matched) { + num_matched++; + } + candidates.emplace_back(std::move(candidate)); } // Sort the candidates with the most promising first - std::stable_sort(candidates.begin(), candidates.end(), - [](const Candidate& a, const Candidate& b) { return a.score > b.score; }); - - // Generate an error message - std::stringstream ss; - ss << "no matching overload for " << CallSignature(builder, intrinsic_name, {lhs, rhs}) - << std::endl; - if (!candidates.empty()) { - ss << std::endl; - ss << candidates.size() << " candidate operator" << (candidates.size() > 1 ? "s:" : ":") - << std::endl; - for (auto& candidate : candidates) { - ss << " "; - PrintOverload(ss, *candidate.overload, intrinsic_name); - ss << std::endl; + { + std::vector candidate_indices(candidates.size()); + for (size_t i = 0; i < candidate_indices.size(); i++) { + candidate_indices[i] = i; } + std::stable_sort(candidate_indices.begin(), candidate_indices.end(), + [&](size_t a, size_t b) { + if (candidates[a].matched && !candidates[b].matched) { + return true; + } + if (candidates[b].matched && !candidates[a].matched) { + return false; + } + return candidates[a].score > candidates[b].score; + }); + Candidates candidates_sorted; + candidates_sorted.reserve(candidate_indices.size()); + for (size_t idx : candidate_indices) { + candidates_sorted.emplace_back(std::move(candidates[idx])); + } + std::swap(candidates, candidates_sorted); } - builder.Diagnostics().add_error(diag::System::Resolver, ss.str(), source); - return {}; + + // How many candidates matched? + switch (num_matched) { + case 0: + on_no_match(std::move(candidates)); + return {}; + case 1: + break; + default: + ErrMultipleOverloadsMatched(num_matched, intrinsic_name, args, closed, candidates); + } + + auto match = candidates[0]; + + // Build the return type + const sem::Type* return_type = nullptr; + if (auto* indices = match.overload.return_matcher_indices) { + Any any; + return_type = Match(match.closed, match.overload, indices).Type(&any); + if (!return_type) { + TINT_ICE(Resolver, builder.Diagnostics()) << "MatchState.Match() returned null"; + return {}; + } + } else { + return_type = builder.create(); + } + + return IntrinsicPrototype{&match.overload, return_type, std::move(match.parameters)}; } -const IntrinsicPrototype Impl::Match(const char* intrinsic_name, - const OverloadInfo& overload, - const std::vector& args, - int& match_score) { - // Score wait for argument <-> parameter count matches / mismatches +Impl::Candidate Impl::ScoreOverload(const OverloadInfo& overload, + const std::vector& args, + ClosedState closed) const { + // Score weight for argument <-> parameter count matches / mismatches + // This scoring is used to order the suggested overloads in diagnostic on overload mismatch, and + // has no impact for a correct program. + // The overloads with the highest score will be displayed first (top-most). constexpr int kScorePerParamArgMismatch = -1; constexpr int kScorePerMatchedParam = 2; constexpr int kScorePerMatchedOpenType = 1; @@ -1117,6 +1312,7 @@ const IntrinsicPrototype Impl::Match(const char* intrinsic_name, uint32_t num_arguments = static_cast(args.size()); bool overload_matched = true; + int overload_score = 0; if (static_cast(args.size()) > static_cast(std::numeric_limits::max())) { @@ -1124,13 +1320,11 @@ const IntrinsicPrototype Impl::Match(const char* intrinsic_name, } if (num_parameters != num_arguments) { - match_score += kScorePerParamArgMismatch * (std::max(num_parameters, num_arguments) - - std::min(num_parameters, num_arguments)); + overload_score += kScorePerParamArgMismatch * (std::max(num_parameters, num_arguments) - + std::min(num_parameters, num_arguments)); overload_matched = false; } - ClosedState closed(builder); - std::vector parameters; auto num_params = std::min(num_parameters, num_arguments); @@ -1140,7 +1334,7 @@ const IntrinsicPrototype Impl::Match(const char* intrinsic_name, auto* type = Match(closed, overload, indices).Type(args[p]->UnwrapRef()); if (type) { parameters.emplace_back(IntrinsicPrototype::Parameter{type, parameter.usage}); - match_score += kScorePerMatchedParam; + overload_score += kScorePerMatchedParam; } else { overload_matched = false; } @@ -1151,9 +1345,10 @@ const IntrinsicPrototype Impl::Match(const char* intrinsic_name, for (uint32_t ot = 0; ot < overload.num_open_types; ot++) { auto& open_type = overload.open_types[ot]; if (open_type.matcher_index != kNoMatcher) { - auto* index = &open_type.matcher_index; - if (Match(closed, overload, index).Type(closed.Type(ot))) { - match_score += kScorePerMatchedOpenType; + auto* closed_type = closed.Type(ot); + auto* matcher_index = &open_type.matcher_index; + if (closed_type && Match(closed, overload, matcher_index).Type(closed_type)) { + overload_score += kScorePerMatchedOpenType; } else { overload_matched = false; } @@ -1168,7 +1363,7 @@ const IntrinsicPrototype Impl::Match(const char* intrinsic_name, if (open_number.matcher_index != kNoMatcher) { auto* index = &open_number.matcher_index; if (Match(closed, overload, index).Num(closed.Num(on)).IsValid()) { - match_score += kScorePerMatchedOpenNumber; + overload_score += kScorePerMatchedOpenNumber; } else { overload_matched = false; } @@ -1176,31 +1371,7 @@ const IntrinsicPrototype Impl::Match(const char* intrinsic_name, } } - if (!overload_matched) { - return {}; - } - - // Build the return type - const sem::Type* return_type = nullptr; - if (auto* indices = overload.return_matcher_indices) { - Any any; - return_type = Match(closed, overload, indices).Type(&any); - if (!return_type) { - std::stringstream ss; - PrintOverload(ss, overload, intrinsic_name); - TINT_ICE(Resolver, builder.Diagnostics()) - << "MatchState.Match() returned null for " << ss.str(); - return {}; - } - } else { - return_type = builder.create(); - } - - IntrinsicPrototype builtin; - builtin.overload = &overload; - builtin.return_type = return_type; - builtin.parameters = std::move(parameters); - return builtin; + return Candidate{overload, closed, parameters, overload_matched, overload_score}; } MatchState Impl::Match(ClosedState& closed, @@ -1209,10 +1380,12 @@ MatchState Impl::Match(ClosedState& closed, return MatchState(builder, closed, matchers, overload, matcher_indices); } -void Impl::PrintOverload(std::ostream& ss, const OverloadInfo& overload, const char* name) const { +void Impl::PrintOverload(std::ostream& ss, + const OverloadInfo& overload, + const char* intrinsic_name) const { ClosedState closed(builder); - ss << name << "("; + ss << intrinsic_name << "("; for (uint32_t p = 0; p < overload.num_parameters; p++) { auto& parameter = overload.parameters[p]; if (p > 0) { @@ -1256,6 +1429,16 @@ void Impl::PrintOverload(std::ostream& ss, const OverloadInfo& overload, const c } } +void Impl::PrintCandidates(std::ostream& ss, + const Candidates& candidates, + const char* intrinsic_name) const { + for (auto& candidate : candidates) { + ss << " "; + PrintOverload(ss, candidate.overload, intrinsic_name); + ss << std::endl; + } +} + const sem::Type* MatchState::Type(const sem::Type* ty) { MatcherIndex matcher_index = *matcher_indices_++; auto* matcher = matchers.type[matcher_index]; @@ -1280,6 +1463,41 @@ std::string MatchState::NumName() { return matcher->String(*this); } +void Impl::ErrMultipleOverloadsMatched(uint32_t num_matched, + const char* intrinsic_name, + const std::vector& args, + ClosedState closed, + Candidates candidates) const { + std::stringstream ss; + ss << num_matched << " overloads matched " << intrinsic_name; + for (uint32_t i = 0; i < 0xffffffffu; i++) { + if (auto* ty = closed.Type(i)) { + ss << ((i == 0) ? "<" : ", ") << ty->FriendlyName(builder.Symbols()); + } else if (i > 0) { + ss << ">"; + break; + } + } + ss << "("; + bool first = true; + for (auto* arg : args) { + if (!first) { + ss << ", "; + } + first = false; + ss << arg->FriendlyName(builder.Symbols()); + } + ss << "):\n"; + for (auto& candidate : candidates) { + if (candidate.matched) { + ss << " "; + PrintOverload(ss, candidate.overload, intrinsic_name); + ss << std::endl; + } + } + TINT_ICE(Resolver, builder.Diagnostics()) << ss.str(); +} + } // namespace std::unique_ptr IntrinsicTable::Create(ProgramBuilder& builder) { diff --git a/src/tint/resolver/intrinsic_table.h b/src/tint/resolver/intrinsic_table.h index 93951769c2..5a8985fea0 100644 --- a/src/tint/resolver/intrinsic_table.h +++ b/src/tint/resolver/intrinsic_table.h @@ -19,6 +19,7 @@ #include #include +#include "src/tint/resolver/ctor_conv_intrinsic.h" #include "src/tint/sem/builtin.h" // Forward declarations @@ -89,6 +90,18 @@ class IntrinsicTable { const sem::Type* rhs, const Source& source, bool is_compound) = 0; + + /// Lookup looks for the type constructor or conversion overload for the given + /// CtorConvIntrinsic. + /// @param type the type being constructed or converted + /// @param template_arg the optional template argument + /// @param args the argument types passed to the constructor / conversion call + /// @param source the source of the call + /// @return a sem::TypeConstructor, sem::TypeConversion or nullptr if nothing matched + virtual const sem::CallTarget* Lookup(CtorConvIntrinsic type, + const sem::Type* template_arg, + const std::vector& args, + const Source& source) = 0; }; } // namespace tint::resolver diff --git a/src/tint/resolver/intrinsic_table.inl b/src/tint/resolver/intrinsic_table.inl index e34ab5faab..f3c4e76269 100644 --- a/src/tint/resolver/intrinsic_table.inl +++ b/src/tint/resolver/intrinsic_table.inl @@ -231,8 +231,305 @@ std::string Vec4::String(MatchState& state) const { return "vec4<" + T + ">"; } +/// TypeMatcher for 'type mat2x2' +/// @see src/tint/intrinsics.def:75:6 +class Mat2X2 : 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* Mat2X2::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat2x2(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat2x2(state, T); +} + +std::string Mat2X2::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat2x2<" + T + ">"; +} + +/// TypeMatcher for 'type mat2x3' +/// @see src/tint/intrinsics.def:76:6 +class Mat2X3 : 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* Mat2X3::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat2x3(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat2x3(state, T); +} + +std::string Mat2X3::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat2x3<" + T + ">"; +} + +/// TypeMatcher for 'type mat2x4' +/// @see src/tint/intrinsics.def:77:6 +class Mat2X4 : 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* Mat2X4::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat2x4(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat2x4(state, T); +} + +std::string Mat2X4::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat2x4<" + T + ">"; +} + +/// TypeMatcher for 'type mat3x2' +/// @see src/tint/intrinsics.def:78:6 +class Mat3X2 : 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* Mat3X2::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat3x2(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat3x2(state, T); +} + +std::string Mat3X2::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat3x2<" + T + ">"; +} + +/// TypeMatcher for 'type mat3x3' +/// @see src/tint/intrinsics.def:79:6 +class Mat3X3 : 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* Mat3X3::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat3x3(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat3x3(state, T); +} + +std::string Mat3X3::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat3x3<" + T + ">"; +} + +/// TypeMatcher for 'type mat3x4' +/// @see src/tint/intrinsics.def:80:6 +class Mat3X4 : 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* Mat3X4::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat3x4(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat3x4(state, T); +} + +std::string Mat3X4::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat3x4<" + T + ">"; +} + +/// TypeMatcher for 'type mat4x2' +/// @see src/tint/intrinsics.def:81:6 +class Mat4X2 : 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* Mat4X2::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat4x2(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat4x2(state, T); +} + +std::string Mat4X2::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat4x2<" + T + ">"; +} + +/// TypeMatcher for 'type mat4x3' +/// @see src/tint/intrinsics.def:82:6 +class Mat4X3 : 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* Mat4X3::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat4x3(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat4x3(state, T); +} + +std::string Mat4X3::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat4x3<" + T + ">"; +} + +/// TypeMatcher for 'type mat4x4' +/// @see src/tint/intrinsics.def:83:6 +class Mat4X4 : 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* Mat4X4::Match(MatchState& state, const sem::Type* ty) const { + const sem::Type* T = nullptr; + if (!match_mat4x4(ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return build_mat4x4(state, T); +} + +std::string Mat4X4::String(MatchState& state) const { + const std::string T = state.TypeName(); + return "mat4x4<" + T + ">"; +} + /// TypeMatcher for 'type vec' -/// @see src/tint/intrinsics.def:75:37 +/// @see src/tint/intrinsics.def:84:37 class Vec : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -273,7 +570,7 @@ std::string Vec::String(MatchState& state) const { } /// TypeMatcher for 'type mat' -/// @see src/tint/intrinsics.def:76:37 +/// @see src/tint/intrinsics.def:85:37 class Mat : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -320,7 +617,7 @@ std::string Mat::String(MatchState& state) const { } /// TypeMatcher for 'type ptr' -/// @see src/tint/intrinsics.def:77:6 +/// @see src/tint/intrinsics.def:86:6 class Ptr : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -365,7 +662,7 @@ std::string Ptr::String(MatchState& state) const { } /// TypeMatcher for 'type atomic' -/// @see src/tint/intrinsics.def:78:6 +/// @see src/tint/intrinsics.def:87:6 class Atomic : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -398,7 +695,7 @@ std::string Atomic::String(MatchState& state) const { } /// TypeMatcher for 'type array' -/// @see src/tint/intrinsics.def:79:6 +/// @see src/tint/intrinsics.def:88:6 class Array : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -431,7 +728,7 @@ std::string Array::String(MatchState& state) const { } /// TypeMatcher for 'type sampler' -/// @see src/tint/intrinsics.def:80:6 +/// @see src/tint/intrinsics.def:89:6 class Sampler : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -458,7 +755,7 @@ std::string Sampler::String(MatchState&) const { } /// TypeMatcher for 'type sampler_comparison' -/// @see src/tint/intrinsics.def:81:6 +/// @see src/tint/intrinsics.def:90:6 class SamplerComparison : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -485,7 +782,7 @@ std::string SamplerComparison::String(MatchState&) const { } /// TypeMatcher for 'type texture_1d' -/// @see src/tint/intrinsics.def:82:6 +/// @see src/tint/intrinsics.def:91:6 class Texture1D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -518,7 +815,7 @@ std::string Texture1D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_2d' -/// @see src/tint/intrinsics.def:83:6 +/// @see src/tint/intrinsics.def:92:6 class Texture2D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -551,7 +848,7 @@ std::string Texture2D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_2d_array' -/// @see src/tint/intrinsics.def:84:6 +/// @see src/tint/intrinsics.def:93:6 class Texture2DArray : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -584,7 +881,7 @@ std::string Texture2DArray::String(MatchState& state) const { } /// TypeMatcher for 'type texture_3d' -/// @see src/tint/intrinsics.def:85:6 +/// @see src/tint/intrinsics.def:94:6 class Texture3D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -617,7 +914,7 @@ std::string Texture3D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_cube' -/// @see src/tint/intrinsics.def:86:6 +/// @see src/tint/intrinsics.def:95:6 class TextureCube : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -650,7 +947,7 @@ std::string TextureCube::String(MatchState& state) const { } /// TypeMatcher for 'type texture_cube_array' -/// @see src/tint/intrinsics.def:87:6 +/// @see src/tint/intrinsics.def:96:6 class TextureCubeArray : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -683,7 +980,7 @@ std::string TextureCubeArray::String(MatchState& state) const { } /// TypeMatcher for 'type texture_multisampled_2d' -/// @see src/tint/intrinsics.def:88:6 +/// @see src/tint/intrinsics.def:97:6 class TextureMultisampled2D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -716,7 +1013,7 @@ std::string TextureMultisampled2D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_depth_2d' -/// @see src/tint/intrinsics.def:89:6 +/// @see src/tint/intrinsics.def:98:6 class TextureDepth2D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -743,7 +1040,7 @@ std::string TextureDepth2D::String(MatchState&) const { } /// TypeMatcher for 'type texture_depth_2d_array' -/// @see src/tint/intrinsics.def:90:6 +/// @see src/tint/intrinsics.def:99:6 class TextureDepth2DArray : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -770,7 +1067,7 @@ std::string TextureDepth2DArray::String(MatchState&) const { } /// TypeMatcher for 'type texture_depth_cube' -/// @see src/tint/intrinsics.def:91:6 +/// @see src/tint/intrinsics.def:100:6 class TextureDepthCube : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -797,7 +1094,7 @@ std::string TextureDepthCube::String(MatchState&) const { } /// TypeMatcher for 'type texture_depth_cube_array' -/// @see src/tint/intrinsics.def:92:6 +/// @see src/tint/intrinsics.def:101:6 class TextureDepthCubeArray : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -824,7 +1121,7 @@ std::string TextureDepthCubeArray::String(MatchState&) const { } /// TypeMatcher for 'type texture_depth_multisampled_2d' -/// @see src/tint/intrinsics.def:93:6 +/// @see src/tint/intrinsics.def:102:6 class TextureDepthMultisampled2D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -851,7 +1148,7 @@ std::string TextureDepthMultisampled2D::String(MatchState&) const { } /// TypeMatcher for 'type texture_storage_1d' -/// @see src/tint/intrinsics.def:94:6 +/// @see src/tint/intrinsics.def:103:6 class TextureStorage1D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -890,7 +1187,7 @@ std::string TextureStorage1D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_storage_2d' -/// @see src/tint/intrinsics.def:95:6 +/// @see src/tint/intrinsics.def:104:6 class TextureStorage2D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -929,7 +1226,7 @@ std::string TextureStorage2D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_storage_2d_array' -/// @see src/tint/intrinsics.def:96:6 +/// @see src/tint/intrinsics.def:105:6 class TextureStorage2DArray : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -968,7 +1265,7 @@ std::string TextureStorage2DArray::String(MatchState& state) const { } /// TypeMatcher for 'type texture_storage_3d' -/// @see src/tint/intrinsics.def:97:6 +/// @see src/tint/intrinsics.def:106:6 class TextureStorage3D : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -1007,7 +1304,7 @@ std::string TextureStorage3D::String(MatchState& state) const { } /// TypeMatcher for 'type texture_external' -/// @see src/tint/intrinsics.def:98:6 +/// @see src/tint/intrinsics.def:107:6 class TextureExternal : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -1034,7 +1331,7 @@ std::string TextureExternal::String(MatchState&) const { } /// TypeMatcher for 'type __modf_result' -/// @see src/tint/intrinsics.def:100:6 +/// @see src/tint/intrinsics.def:109:6 class ModfResult : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -1061,7 +1358,7 @@ std::string ModfResult::String(MatchState&) const { } /// TypeMatcher for 'type __modf_result_vec' -/// @see src/tint/intrinsics.def:101:42 +/// @see src/tint/intrinsics.def:110:42 class ModfResultVec : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -1096,7 +1393,7 @@ std::string ModfResultVec::String(MatchState& state) const { } /// TypeMatcher for 'type __frexp_result' -/// @see src/tint/intrinsics.def:102:6 +/// @see src/tint/intrinsics.def:111:6 class FrexpResult : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -1123,7 +1420,7 @@ std::string FrexpResult::String(MatchState&) const { } /// TypeMatcher for 'type __frexp_result_vec' -/// @see src/tint/intrinsics.def:103:43 +/// @see src/tint/intrinsics.def:112:43 class FrexpResultVec : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules. @@ -1158,7 +1455,7 @@ std::string FrexpResultVec::String(MatchState& state) const { } /// TypeMatcher for 'match fiu32' -/// @see src/tint/intrinsics.def:111:7 +/// @see src/tint/intrinsics.def:120:7 class Fiu32 : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules, and returns the @@ -1192,7 +1489,7 @@ std::string Fiu32::String(MatchState&) const { } /// TypeMatcher for 'match fi32' -/// @see src/tint/intrinsics.def:112:7 +/// @see src/tint/intrinsics.def:121:7 class Fi32 : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules, and returns the @@ -1223,7 +1520,7 @@ std::string Fi32::String(MatchState&) const { } /// TypeMatcher for 'match iu32' -/// @see src/tint/intrinsics.def:113:7 +/// @see src/tint/intrinsics.def:122:7 class Iu32 : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules, and returns the @@ -1254,7 +1551,7 @@ std::string Iu32::String(MatchState&) const { } /// TypeMatcher for 'match scalar' -/// @see src/tint/intrinsics.def:114:7 +/// @see src/tint/intrinsics.def:123:7 class Scalar : public TypeMatcher { public: /// Checks whether the given type matches the matcher rules, and returns the @@ -1290,8 +1587,144 @@ std::string Scalar::String(MatchState&) const { return "f32, i32, u32 or bool"; } -/// EnumMatcher for 'match f32_texel_format' +/// TypeMatcher for 'match scalar_no_f32' +/// @see src/tint/intrinsics.def:124:7 +class ScalarNoF32 : 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* ScalarNoF32::Match(MatchState& state, const sem::Type* ty) const { + 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 ScalarNoF32::String(MatchState&) const { + return "i32, u32 or bool"; +} + +/// TypeMatcher for 'match scalar_no_i32' /// @see src/tint/intrinsics.def:125:7 +class ScalarNoI32 : 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* ScalarNoI32::Match(MatchState& state, const sem::Type* ty) const { + if (match_f32(ty)) { + return build_f32(state); + } + if (match_u32(ty)) { + return build_u32(state); + } + if (match_bool(ty)) { + return build_bool(state); + } + return nullptr; +} + +std::string ScalarNoI32::String(MatchState&) const { + return "f32, u32 or bool"; +} + +/// TypeMatcher for 'match scalar_no_u32' +/// @see src/tint/intrinsics.def:126:7 +class ScalarNoU32 : 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* ScalarNoU32::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_bool(ty)) { + return build_bool(state); + } + return nullptr; +} + +std::string ScalarNoU32::String(MatchState&) const { + return "f32, i32 or bool"; +} + +/// TypeMatcher for 'match scalar_no_bool' +/// @see src/tint/intrinsics.def:127:7 +class ScalarNoBool : 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* ScalarNoBool::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 ScalarNoBool::String(MatchState&) const { + return "f32, i32 or u32"; +} + +/// EnumMatcher for 'match f32_texel_format' +/// @see src/tint/intrinsics.def:138:7 class F32TexelFormat : public NumberMatcher { public: /// Checks whether the given number matches the enum matcher rules. @@ -1324,7 +1757,7 @@ std::string F32TexelFormat::String(MatchState&) const { } /// EnumMatcher for 'match i32_texel_format' -/// @see src/tint/intrinsics.def:127:7 +/// @see src/tint/intrinsics.def:140:7 class I32TexelFormat : public NumberMatcher { public: /// Checks whether the given number matches the enum matcher rules. @@ -1356,7 +1789,7 @@ std::string I32TexelFormat::String(MatchState&) const { } /// EnumMatcher for 'match u32_texel_format' -/// @see src/tint/intrinsics.def:129:7 +/// @see src/tint/intrinsics.def:142:7 class U32TexelFormat : public NumberMatcher { public: /// Checks whether the given number matches the enum matcher rules. @@ -1388,7 +1821,7 @@ std::string U32TexelFormat::String(MatchState&) const { } /// EnumMatcher for 'match write_only' -/// @see src/tint/intrinsics.def:132:7 +/// @see src/tint/intrinsics.def:145:7 class WriteOnly : public NumberMatcher { public: /// Checks whether the given number matches the enum matcher rules. @@ -1414,7 +1847,7 @@ std::string WriteOnly::String(MatchState&) const { } /// EnumMatcher for 'match function_private_workgroup' -/// @see src/tint/intrinsics.def:134:7 +/// @see src/tint/intrinsics.def:147:7 class FunctionPrivateWorkgroup : public NumberMatcher { public: /// Checks whether the given number matches the enum matcher rules. @@ -1444,7 +1877,7 @@ std::string FunctionPrivateWorkgroup::String(MatchState&) const { } /// EnumMatcher for 'match workgroup_or_storage' -/// @see src/tint/intrinsics.def:135:7 +/// @see src/tint/intrinsics.def:148:7 class WorkgroupOrStorage : public NumberMatcher { public: /// Checks whether the given number matches the enum matcher rules. @@ -1551,6 +1984,7 @@ std::string ReadWrite::String(MatchState&) const { class Matchers { private: OpenTypeMatcher open_type_0_{0}; + OpenTypeMatcher open_type_1_{1}; OpenNumberMatcher open_number_0_{0}; OpenNumberMatcher open_number_1_{1}; OpenNumberMatcher open_number_2_{2}; @@ -1561,6 +1995,15 @@ class Matchers { Vec2 Vec2_; Vec3 Vec3_; Vec4 Vec4_; + Mat2X2 Mat2X2_; + Mat2X3 Mat2X3_; + Mat2X4 Mat2X4_; + Mat3X2 Mat3X2_; + Mat3X3 Mat3X3_; + Mat3X4 Mat3X4_; + Mat4X2 Mat4X2_; + Mat4X3 Mat4X3_; + Mat4X4 Mat4X4_; Vec Vec_; Mat Mat_; Ptr Ptr_; @@ -1593,6 +2036,10 @@ class Matchers { Fi32 Fi32_; Iu32 Iu32_; Scalar Scalar_; + ScalarNoF32 ScalarNoF32_; + ScalarNoI32 ScalarNoI32_; + ScalarNoU32 ScalarNoU32_; + ScalarNoBool ScalarNoBool_; F32TexelFormat F32TexelFormat_; I32TexelFormat I32TexelFormat_; U32TexelFormat U32TexelFormat_; @@ -1610,47 +2057,61 @@ class Matchers { ~Matchers(); /// The open-types, types, and type matchers - TypeMatcher const* const type[40] = { + TypeMatcher const* const type[54] = { /* [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] */ &Fi32_, - /* [38] */ &Iu32_, - /* [39] */ &Scalar_, + /* [1] */ &open_type_1_, + /* [2] */ &Bool_, + /* [3] */ &F32_, + /* [4] */ &I32_, + /* [5] */ &U32_, + /* [6] */ &Vec2_, + /* [7] */ &Vec3_, + /* [8] */ &Vec4_, + /* [9] */ &Mat2X2_, + /* [10] */ &Mat2X3_, + /* [11] */ &Mat2X4_, + /* [12] */ &Mat3X2_, + /* [13] */ &Mat3X3_, + /* [14] */ &Mat3X4_, + /* [15] */ &Mat4X2_, + /* [16] */ &Mat4X3_, + /* [17] */ &Mat4X4_, + /* [18] */ &Vec_, + /* [19] */ &Mat_, + /* [20] */ &Ptr_, + /* [21] */ &Atomic_, + /* [22] */ &Array_, + /* [23] */ &Sampler_, + /* [24] */ &SamplerComparison_, + /* [25] */ &Texture1D_, + /* [26] */ &Texture2D_, + /* [27] */ &Texture2DArray_, + /* [28] */ &Texture3D_, + /* [29] */ &TextureCube_, + /* [30] */ &TextureCubeArray_, + /* [31] */ &TextureMultisampled2D_, + /* [32] */ &TextureDepth2D_, + /* [33] */ &TextureDepth2DArray_, + /* [34] */ &TextureDepthCube_, + /* [35] */ &TextureDepthCubeArray_, + /* [36] */ &TextureDepthMultisampled2D_, + /* [37] */ &TextureStorage1D_, + /* [38] */ &TextureStorage2D_, + /* [39] */ &TextureStorage2DArray_, + /* [40] */ &TextureStorage3D_, + /* [41] */ &TextureExternal_, + /* [42] */ &ModfResult_, + /* [43] */ &ModfResultVec_, + /* [44] */ &FrexpResult_, + /* [45] */ &FrexpResultVec_, + /* [46] */ &Fiu32_, + /* [47] */ &Fi32_, + /* [48] */ &Iu32_, + /* [49] */ &Scalar_, + /* [50] */ &ScalarNoF32_, + /* [51] */ &ScalarNoI32_, + /* [52] */ &ScalarNoU32_, + /* [53] */ &ScalarNoBool_, }; /// The open-numbers, and number matchers @@ -1674,159 +2135,194 @@ Matchers::Matchers() = default; Matchers::~Matchers() = default; constexpr MatcherIndex kMatcherIndices[] = { - /* [0] */ 30, - /* [1] */ 4, - /* [2] */ 10, + /* [0] */ 20, + /* [1] */ 0, + /* [2] */ 21, /* [3] */ 0, /* [4] */ 11, - /* [5] */ 0, - /* [6] */ 11, - /* [7] */ 10, - /* [8] */ 9, - /* [9] */ 12, + /* [5] */ 3, + /* [6] */ 20, + /* [7] */ 9, + /* [8] */ 22, + /* [9] */ 0, /* [10] */ 0, - /* [11] */ 0, - /* [12] */ 9, - /* [13] */ 0, - /* [14] */ 0, - /* [15] */ 2, - /* [16] */ 9, + /* [11] */ 19, + /* [12] */ 0, + /* [13] */ 1, + /* [14] */ 3, + /* [15] */ 19, + /* [16] */ 1, /* [17] */ 0, - /* [18] */ 1, - /* [19] */ 2, - /* [20] */ 9, - /* [21] */ 1, - /* [22] */ 0, - /* [23] */ 2, - /* [24] */ 9, - /* [25] */ 0, - /* [26] */ 2, - /* [27] */ 2, - /* [28] */ 9, - /* [29] */ 1, - /* [30] */ 2, - /* [31] */ 2, - /* [32] */ 8, - /* [33] */ 0, - /* [34] */ 2, - /* [35] */ 8, - /* [36] */ 0, - /* [37] */ 1, - /* [38] */ 8, + /* [18] */ 3, + /* [19] */ 19, + /* [20] */ 0, + /* [21] */ 0, + /* [22] */ 3, + /* [23] */ 19, + /* [24] */ 0, + /* [25] */ 2, + /* [26] */ 3, + /* [27] */ 19, + /* [28] */ 1, + /* [29] */ 2, + /* [30] */ 3, + /* [31] */ 18, + /* [32] */ 0, + /* [33] */ 3, + /* [34] */ 40, + /* [35] */ 5, + /* [36] */ 10, + /* [37] */ 3, + /* [38] */ 18, /* [39] */ 0, /* [40] */ 0, - /* [41] */ 29, + /* [41] */ 18, /* [42] */ 0, - /* [43] */ 1, - /* [44] */ 30, - /* [45] */ 0, - /* [46] */ 1, - /* [47] */ 8, - /* [48] */ 1, - /* [49] */ 2, - /* [50] */ 28, - /* [51] */ 0, - /* [52] */ 1, - /* [53] */ 27, + /* [43] */ 2, + /* [44] */ 39, + /* [45] */ 5, + /* [46] */ 10, + /* [47] */ 38, + /* [48] */ 5, + /* [49] */ 10, + /* [50] */ 37, + /* [51] */ 5, + /* [52] */ 10, + /* [53] */ 40, /* [54] */ 0, /* [55] */ 1, - /* [56] */ 8, + /* [56] */ 39, /* [57] */ 0, - /* [58] */ 3, - /* [59] */ 8, + /* [58] */ 1, + /* [59] */ 38, /* [60] */ 0, - /* [61] */ 4, - /* [62] */ 27, - /* [63] */ 3, - /* [64] */ 10, - /* [65] */ 28, - /* [66] */ 3, + /* [61] */ 1, + /* [62] */ 37, + /* [63] */ 0, + /* [64] */ 1, + /* [65] */ 40, + /* [66] */ 4, /* [67] */ 10, - /* [68] */ 29, - /* [69] */ 3, + /* [68] */ 39, + /* [69] */ 4, /* [70] */ 10, - /* [71] */ 30, - /* [72] */ 3, + /* [71] */ 38, + /* [72] */ 4, /* [73] */ 10, - /* [74] */ 27, + /* [74] */ 37, /* [75] */ 4, /* [76] */ 10, - /* [77] */ 28, - /* [78] */ 4, + /* [77] */ 40, + /* [78] */ 3, /* [79] */ 10, - /* [80] */ 30, - /* [81] */ 5, - /* [82] */ 10, - /* [83] */ 29, - /* [84] */ 5, + /* [80] */ 18, + /* [81] */ 1, + /* [82] */ 3, + /* [83] */ 39, + /* [84] */ 3, /* [85] */ 10, - /* [86] */ 29, - /* [87] */ 4, + /* [86] */ 38, + /* [87] */ 3, /* [88] */ 10, - /* [89] */ 28, - /* [90] */ 5, - /* [91] */ 10, - /* [92] */ 27, - /* [93] */ 5, - /* [94] */ 10, - /* [95] */ 6, + /* [89] */ 18, + /* [90] */ 0, + /* [91] */ 4, + /* [92] */ 18, + /* [93] */ 0, + /* [94] */ 5, + /* [95] */ 37, /* [96] */ 3, - /* [97] */ 7, - /* [98] */ 3, - /* [99] */ 5, - /* [100] */ 3, - /* [101] */ 7, - /* [102] */ 4, - /* [103] */ 15, - /* [104] */ 0, - /* [105] */ 7, - /* [106] */ 0, - /* [107] */ 16, - /* [108] */ 0, - /* [109] */ 7, - /* [110] */ 2, - /* [111] */ 17, - /* [112] */ 0, - /* [113] */ 5, - /* [114] */ 2, - /* [115] */ 33, - /* [116] */ 0, - /* [117] */ 18, - /* [118] */ 0, - /* [119] */ 21, - /* [120] */ 0, - /* [121] */ 6, - /* [122] */ 2, - /* [123] */ 20, - /* [124] */ 2, - /* [125] */ 19, - /* [126] */ 0, - /* [127] */ 19, - /* [128] */ 2, - /* [129] */ 20, - /* [130] */ 0, - /* [131] */ 18, - /* [132] */ 2, - /* [133] */ 17, - /* [134] */ 2, - /* [135] */ 5, - /* [136] */ 0, - /* [137] */ 35, - /* [138] */ 0, - /* [139] */ 16, - /* [140] */ 2, - /* [141] */ 15, - /* [142] */ 2, - /* [143] */ 13, - /* [144] */ 23, - /* [145] */ 24, - /* [146] */ 25, - /* [147] */ 22, - /* [148] */ 26, - /* [149] */ 14, + /* [97] */ 10, + /* [98] */ 6, + /* [99] */ 3, + /* [100] */ 8, + /* [101] */ 3, + /* [102] */ 43, + /* [103] */ 0, + /* [104] */ 6, + /* [105] */ 0, + /* [106] */ 6, + /* [107] */ 1, + /* [108] */ 6, + /* [109] */ 4, + /* [110] */ 6, + /* [111] */ 5, + /* [112] */ 6, + /* [113] */ 2, + /* [114] */ 7, + /* [115] */ 0, + /* [116] */ 7, + /* [117] */ 1, + /* [118] */ 7, + /* [119] */ 3, + /* [120] */ 7, + /* [121] */ 4, + /* [122] */ 45, + /* [123] */ 0, + /* [124] */ 7, + /* [125] */ 5, + /* [126] */ 7, + /* [127] */ 2, + /* [128] */ 8, + /* [129] */ 0, + /* [130] */ 17, + /* [131] */ 3, + /* [132] */ 25, + /* [133] */ 0, + /* [134] */ 8, + /* [135] */ 1, + /* [136] */ 26, + /* [137] */ 0, + /* [138] */ 27, + /* [139] */ 0, + /* [140] */ 8, + /* [141] */ 4, + /* [142] */ 28, + /* [143] */ 0, + /* [144] */ 29, + /* [145] */ 0, + /* [146] */ 8, + /* [147] */ 5, + /* [148] */ 30, + /* [149] */ 0, /* [150] */ 31, - /* [151] */ 32, - /* [152] */ 34, + /* [151] */ 0, + /* [152] */ 8, + /* [153] */ 2, + /* [154] */ 9, + /* [155] */ 3, + /* [156] */ 12, + /* [157] */ 3, + /* [158] */ 13, + /* [159] */ 3, + /* [160] */ 14, + /* [161] */ 3, + /* [162] */ 15, + /* [163] */ 3, + /* [164] */ 16, + /* [165] */ 3, + /* [166] */ 25, + /* [167] */ 3, + /* [168] */ 26, + /* [169] */ 3, + /* [170] */ 27, + /* [171] */ 3, + /* [172] */ 28, + /* [173] */ 3, + /* [174] */ 29, + /* [175] */ 3, + /* [176] */ 30, + /* [177] */ 3, + /* [178] */ 24, + /* [179] */ 33, + /* [180] */ 34, + /* [181] */ 35, + /* [182] */ 32, + /* [183] */ 23, + /* [184] */ 41, + /* [185] */ 36, + /* [186] */ 42, + /* [187] */ 44, }; // Assert that the MatcherIndex is big enough to index all the matchers, plus @@ -1838,2628 +2334,2628 @@ static_assert(static_cast(sizeof(kMatcherIndices) / sizeof(kMatcherIndices[ constexpr ParameterInfo kParameters[] = { { /* [0] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [1] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [2] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [3] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [4] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [5] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [6] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [7] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [8] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [9] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [10] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [11] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [12] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [13] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [14] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [15] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [16] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [17] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [18] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [19] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [20] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [21] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [22] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [23] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [24] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [25] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[123], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [26] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [27] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [28] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [29] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [30] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [31] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [32] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [33] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [34] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [35] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [36] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [37] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [38] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [39] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [40] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [41] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [42] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [43] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [44] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [45] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [46] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [47] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [48] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[95], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [49] */ - /* usage */ ParameterUsage::kComponent, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [50] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [51] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [52] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [53] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [54] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [55] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [56] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [57] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [58] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [59] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [60] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [61] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [62] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [63] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [64] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [65] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[170], }, { /* [66] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [67] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [68] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [69] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[98], }, { /* [70] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[98], }, { /* [71] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [72] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[176], }, { /* [73] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [74] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [75] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [76] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[118], }, { /* [77] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[95], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[118], }, { /* [78] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* matcher indices */ &kMatcherIndices[170], }, { /* [79] */ /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* matcher indices */ &kMatcherIndices[183], }, { /* [80] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* matcher indices */ &kMatcherIndices[98], }, { /* [81] */ /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* matcher indices */ &kMatcherIndices[66], }, { /* [82] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], }, { /* [83] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [84] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [85] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [86] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [87] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [88] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [89] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [90] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[170], }, { /* [91] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [92] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [93] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [94] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[98], }, { /* [95] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[98], }, { /* [96] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [97] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [98] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [99] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [100] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [101] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [102] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [103] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [104] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [105] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [106] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [107] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [108] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[123], + /* matcher indices */ &kMatcherIndices[172], }, { /* [109] */ /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* matcher indices */ &kMatcherIndices[183], }, { /* [110] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* matcher indices */ &kMatcherIndices[118], }, { /* [111] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[118], }, { /* [112] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[118], }, { /* [113] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[120], }, { /* [114] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], }, { /* [115] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [116] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [117] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[98], }, { /* [118] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[98], }, { /* [119] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [120] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [121] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [122] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [123] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[123], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [124] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [125] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [126] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [127] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [128] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [129] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [130] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [131] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [132] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kComponent, + /* matcher indices */ &kMatcherIndices[66], }, { /* [133] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], + /* matcher indices */ &kMatcherIndices[138], }, { /* [134] */ /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* matcher indices */ &kMatcherIndices[183], }, { /* [135] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* matcher indices */ &kMatcherIndices[98], }, { /* [136] */ /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* matcher indices */ &kMatcherIndices[66], }, { /* [137] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [138] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* matcher indices */ &kMatcherIndices[170], }, { /* [139] */ /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* matcher indices */ &kMatcherIndices[183], }, { /* [140] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* matcher indices */ &kMatcherIndices[98], }, { /* [141] */ /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* matcher indices */ &kMatcherIndices[66], }, { /* [142] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [143] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[127], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [144] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [145] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [146] */ - /* usage */ ParameterUsage::kDdx, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [147] */ - /* usage */ ParameterUsage::kDdy, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [148] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [149] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [150] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [151] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [152] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [153] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [154] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [155] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], }, { /* [156] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [157] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [158] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [159] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [160] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[170], }, { /* [161] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [162] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [163] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [164] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [165] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], }, { /* [166] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [167] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [168] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [169] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[120], }, { /* [170] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [171] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [172] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [173] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [174] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [175] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [176] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [177] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [178] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [179] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [180] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [181] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [182] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [183] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [184] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [185] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [186] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [187] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [188] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [189] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [190] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], }, { /* [191] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [192] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [193] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[118], }, { /* [194] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[118], }, { /* [195] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], }, { /* [196] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [197] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [198] */ - /* usage */ ParameterUsage::kComponent, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [199] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[129], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [200] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [201] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [202] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [203] */ - /* usage */ ParameterUsage::kComponent, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [204] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[107], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [205] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [206] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [207] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [208] */ - /* usage */ ParameterUsage::kComponent, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [209] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [210] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], }, { /* [211] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [212] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [213] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [214] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [215] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kComponent, + /* matcher indices */ &kMatcherIndices[66], }, { /* [216] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[136], }, { /* [217] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[95], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [218] */ - /* usage */ ParameterUsage::kComponent, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [219] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[125], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [220] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], }, { /* [221] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [222] */ - /* usage */ ParameterUsage::kComponent, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [223] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[107], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [224] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [225] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], }, { /* [226] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [227] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [228] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], }, { /* [229] */ /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], + /* matcher indices */ &kMatcherIndices[120], }, { /* [230] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* matcher indices */ &kMatcherIndices[174], }, { /* [231] */ /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* matcher indices */ &kMatcherIndices[183], }, { /* [232] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* matcher indices */ &kMatcherIndices[118], }, { /* [233] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[118], }, { /* [234] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[118], }, { /* [235] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[176], }, { /* [236] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [237] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [238] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [239] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [240] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], }, { /* [241] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [242] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [243] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kDdx, + /* matcher indices */ &kMatcherIndices[98], }, { /* [244] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kDdy, + /* matcher indices */ &kMatcherIndices[98], }, { /* [245] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[170], }, { /* [246] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [247] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [248] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [249] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], }, { /* [250] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[68], + /* matcher indices */ &kMatcherIndices[168], }, { /* [251] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [252] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [253] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[109], + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], }, { /* [254] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], }, { /* [255] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], + /* usage */ ParameterUsage::kComponent, + /* matcher indices */ &kMatcherIndices[66], }, { /* [256] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [257] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [258] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], - }, - { - /* [259] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], - }, - { - /* [260] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [261] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [262] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], - }, - { - /* [263] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[149], - }, - { - /* [264] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [265] */ - /* usage */ ParameterUsage::kDepthRef, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [266] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[127], - }, - { - /* [267] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [268] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [269] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [270] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], - }, - { - /* [271] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [272] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [273] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [274] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], - }, - { - /* [275] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [276] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [277] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [278] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[127], - }, - { - /* [279] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [280] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [281] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [282] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], - }, - { - /* [283] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [284] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [285] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [286] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], - }, - { - /* [287] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [288] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [289] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [290] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], - }, - { - /* [291] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [292] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [293] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [294] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], - }, - { - /* [295] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [296] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [297] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [298] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], - }, - { - /* [299] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [300] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [301] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [302] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], - }, - { - /* [303] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [304] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [305] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [306] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[83], - }, - { - /* [307] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [308] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [309] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[101], - }, - { - /* [310] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [311] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [312] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [313] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [314] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[123], - }, - { - /* [315] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [316] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [317] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [318] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], - }, - { - /* [319] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [320] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [321] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[95], - }, - { - /* [322] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[86], - }, - { - /* [323] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [324] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [325] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[97], - }, - { - /* [326] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], - }, - { - /* [327] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [328] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [329] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [330] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], - }, - { - /* [331] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [332] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [333] */ - /* usage */ ParameterUsage::kOffset, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [334] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[133], - }, - { - /* [335] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [336] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [337] */ - /* usage */ ParameterUsage::kArrayIndex, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [338] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [339] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [340] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [341] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [342] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], - }, - { - /* [343] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [344] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [345] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [346] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], - }, - { - /* [347] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [348] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [349] */ - /* usage */ ParameterUsage::kBias, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [350] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[74], - }, - { - /* [351] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [352] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[97], - }, - { - /* [353] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], - }, - { - /* [354] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [355] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [356] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [357] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [358] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [359] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [360] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [361] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [362] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [363] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [364] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [365] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [366] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [367] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [368] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [369] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [370] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], - }, - { - /* [371] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], - }, - { - /* [372] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [373] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [374] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], - }, - { - /* [375] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [376] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [377] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[131], - }, - { - /* [378] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [379] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], - }, - { - /* [380] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [381] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [382] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [383] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [384] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [385] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [386] */ /* usage */ ParameterUsage::kTexture, /* matcher indices */ &kMatcherIndices[148], }, { - /* [387] */ + /* [257] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [258] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [259] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [260] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [261] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], + }, + { + /* [262] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [263] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [264] */ + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [265] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[176], + }, + { + /* [266] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [267] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [268] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [269] */ + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [270] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [271] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [272] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [273] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [274] */ + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [275] */ + /* usage */ ParameterUsage::kComponent, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [276] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[138], + }, + { + /* [277] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [278] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [279] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [280] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[170], + }, + { + /* [281] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [282] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [283] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [284] */ + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [285] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [286] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [287] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [288] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [289] */ + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [290] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], + }, + { + /* [291] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], + }, + { + /* [292] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [293] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [294] */ + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [295] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[44], + }, + { + /* [296] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [297] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [298] */ + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[146], + }, + { + /* [299] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], + }, + { + /* [300] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [301] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [302] */ + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[120], + }, + { + /* [303] */ + /* usage */ ParameterUsage::kComponent, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [304] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[136], + }, + { + /* [305] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [306] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [307] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [308] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [309] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [310] */ + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [311] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[170], + }, + { + /* [312] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [313] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [314] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [315] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [316] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [317] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [318] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [319] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], + }, + { + /* [320] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [321] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [322] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [323] */ + /* usage */ ParameterUsage::kComponent, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [324] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[144], + }, + { + /* [325] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [326] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [327] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], + }, + { + /* [328] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [329] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [330] */ + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [331] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], + }, + { + /* [332] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [333] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [334] */ + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [335] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [336] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [337] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [338] */ + /* usage */ ParameterUsage::kOffset, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [339] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [340] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [341] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [342] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [343] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], + }, + { + /* [344] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [345] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [346] */ + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [347] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [348] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [349] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [350] */ + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [351] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [352] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [353] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [354] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [355] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [356] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], + }, + { + /* [357] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [358] */ + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [359] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], + }, + { + /* [360] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [361] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [362] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [363] */ + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [364] */ + /* usage */ ParameterUsage::kY, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [365] */ + /* usage */ ParameterUsage::kZ, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [366] */ + /* usage */ ParameterUsage::kW, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [367] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[176], + }, + { + /* [368] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [369] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [370] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [371] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[83], + }, + { + /* [372] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [373] */ + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [374] */ + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [375] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [376] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], + }, + { + /* [377] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [378] */ + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [379] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], + }, + { + /* [380] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [381] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [382] */ + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [383] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [384] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [385] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [386] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [387] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [388] */ - /* usage */ ParameterUsage::kSampleIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [389] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [390] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [391] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[68], }, { /* [392] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [393] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [394] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[140], }, { /* [395] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], }, { /* [396] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [397] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [398] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [399] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[174], }, { /* [400] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [401] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [402] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kBias, + /* matcher indices */ &kMatcherIndices[5], }, { /* [403] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [404] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [405] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [406] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [407] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [408] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [409] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [410] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [411] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[174], }, { /* [412] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [413] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[119], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [414] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[5], }, { /* [415] */ - /* usage */ ParameterUsage::kSampleIndex, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[138], }, { /* [416] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[117], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [417] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[95], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [418] */ /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* matcher indices */ &kMatcherIndices[66], }, { /* [419] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], + /* matcher indices */ &kMatcherIndices[182], }, { /* [420] */ /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* matcher indices */ &kMatcherIndices[183], }, { /* [421] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* matcher indices */ &kMatcherIndices[98], }, { /* [422] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[107], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [423] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [424] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [425] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[103], + /* usage */ ParameterUsage::kArrayIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [426] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [427] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], }, { /* [428] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[80], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], }, { /* [429] */ /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[95], + /* matcher indices */ &kMatcherIndices[118], }, { /* [430] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[101], + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], }, { /* [431] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], }, { /* [432] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], }, { /* [433] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], }, { /* [434] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[127], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], }, { /* [435] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[118], }, { /* [436] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[118], }, { /* [437] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[150], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[118], }, { /* [438] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[118], }, { /* [439] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], }, { /* [440] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[89], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], }, { /* [441] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [442] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[101], - }, - { - /* [443] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[141], - }, - { - /* [444] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [445] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [446] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[62], - }, - { - /* [447] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[58], - }, - { - /* [448] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[109], - }, - { - /* [449] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [450] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, - { - /* [451] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [452] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[0], - }, - { - /* [453] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[95], - }, - { - /* [454] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[97], - }, - { - /* [455] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[139], - }, - { - /* [456] */ - /* usage */ ParameterUsage::kSampler, - /* matcher indices */ &kMatcherIndices[143], - }, - { - /* [457] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[113], - }, - { - /* [458] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[77], - }, - { - /* [459] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [460] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[97], - }, - { - /* [461] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[65], - }, - { - /* [462] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [463] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[109], - }, - { - /* [464] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [465] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [466] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], - }, - { - /* [467] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [468] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [469] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], - }, - { - /* [470] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [471] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], - }, - { - /* [472] */ /* usage */ ParameterUsage::kNone, /* matcher indices */ &kMatcherIndices[35], }, { - /* [473] */ + /* [442] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[35], + }, + { + /* [443] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[71], + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [444] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[178], + }, + { + /* [445] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [446] */ + /* usage */ ParameterUsage::kDepthRef, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [447] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[172], + }, + { + /* [448] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [449] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [450] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [451] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [452] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [453] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [454] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [455] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [456] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [457] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [458] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [459] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [460] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [461] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [462] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [463] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [464] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [465] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [466] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [467] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [468] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[166], + }, + { + /* [469] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [470] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [471] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [472] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [473] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [474] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[95], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[168], }, { /* [475] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[109], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [476] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[92], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [477] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, { /* [478] */ - /* usage */ ParameterUsage::kValue, - /* matcher indices */ &kMatcherIndices[101], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, { /* [479] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[31], }, { /* [480] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[59], + /* matcher indices */ &kMatcherIndices[38], }, { /* [481] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [482] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [483] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [484] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [485] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[35], }, { /* [486] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[174], }, { /* [487] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [488] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], }, { /* [489] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[77], }, { /* [490] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[120], }, { /* [491] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[100], }, { /* [492] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [493] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], + }, + { + /* [494] */ + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [495] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [496] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [497] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [498] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [499] */ + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], + }, + { + /* [500] */ + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[118], + }, + { + /* [501] */ /* usage */ ParameterUsage::kTexture, /* matcher indices */ &kMatcherIndices[150], }, - { - /* [494] */ - /* usage */ ParameterUsage::kCoords, - /* matcher indices */ &kMatcherIndices[99], - }, - { - /* [495] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], - }, - { - /* [496] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [497] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], - }, - { - /* [498] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], - }, - { - /* [499] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [500] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], - }, - { - /* [501] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], - }, { /* [502] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [503] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kSampleIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [504] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], }, { /* [505] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kY, + /* matcher indices */ &kMatcherIndices[1], }, { /* [506] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kZ, + /* matcher indices */ &kMatcherIndices[1], }, { /* [507] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[31], }, { /* [508] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[58], + /* matcher indices */ &kMatcherIndices[31], }, { /* [509] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[5], }, { /* [510] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[56], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[184], }, { /* [511] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kSampler, + /* matcher indices */ &kMatcherIndices[183], }, { /* [512] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[98], }, { /* [513] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[95], }, { /* [514] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[66], }, { /* [515] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[100], }, { /* [516] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kXy, + /* matcher indices */ &kMatcherIndices[104], }, { /* [517] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kZ, + /* matcher indices */ &kMatcherIndices[1], }, { /* [518] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kW, + /* matcher indices */ &kMatcherIndices[1], }, { /* [519] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[86], }, { /* [520] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [521] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[100], }, { /* [522] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [523] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [524] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[25], }, { /* [525] */ @@ -4469,12 +4965,12 @@ constexpr ParameterInfo kParameters[] = { { /* [526] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[38], }, { /* [527] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[25], }, { /* [528] */ @@ -4484,332 +4980,332 @@ constexpr ParameterInfo kParameters[] = { { /* [529] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* matcher indices */ &kMatcherIndices[38], }, { /* [530] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* matcher indices */ &kMatcherIndices[41], }, { /* [531] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], }, { /* [532] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kYz, + /* matcher indices */ &kMatcherIndices[104], }, { /* [533] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[103], + /* usage */ ParameterUsage::kW, + /* matcher indices */ &kMatcherIndices[1], }, { /* [534] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[74], }, { /* [535] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[66], }, { /* [536] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[140], }, { /* [537] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[107], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[0], }, { /* [538] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], }, { /* [539] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [540] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[71], }, { /* [541] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [542] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[140], }, { /* [543] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], }, { /* [544] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kY, + /* matcher indices */ &kMatcherIndices[1], }, { /* [545] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[117], + /* usage */ ParameterUsage::kZw, + /* matcher indices */ &kMatcherIndices[104], }, { /* [546] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], }, { /* [547] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* matcher indices */ &kMatcherIndices[38], }, { /* [548] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* matcher indices */ &kMatcherIndices[38], }, { /* [549] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[125], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [550] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], }, { /* [551] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[5], }, { /* [552] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[31], }, { /* [553] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[129], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, { /* [554] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, { /* [555] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[5], }, { /* [556] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[5], }, { /* [557] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[5], }, { /* [558] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[31], }, { /* [559] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, { /* [560] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, { /* [561] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[65], }, { /* [562] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[120], }, { /* [563] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[140], }, { /* [564] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[50], }, { /* [565] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[66], }, { /* [566] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[146], }, { /* [567] */ /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], + /* matcher indices */ &kMatcherIndices[47], }, { /* [568] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [569] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[146], }, { /* [570] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[98], }, { /* [571] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], }, { /* [572] */ - /* usage */ ParameterUsage::kLevel, - /* matcher indices */ &kMatcherIndices[58], + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], }, { /* [573] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[47], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[34], }, { /* [574] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[120], }, { /* [575] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[24], + /* usage */ ParameterUsage::kValue, + /* matcher indices */ &kMatcherIndices[146], }, { /* [576] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[20], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[132], }, { /* [577] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[66], }, { /* [578] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [579] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[136], }, { /* [580] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [581] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [582] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[118], }, { /* [583] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[118], }, { /* [584] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[118], }, { /* [585] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[142], }, { /* [586] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[120], }, { /* [587] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [588] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[185], }, { /* [589] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [590] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kSampleIndex, + /* matcher indices */ &kMatcherIndices[66], }, { /* [591] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[100], }, { /* [592] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[100], }, { /* [593] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[100], }, { /* [594] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [595] */ @@ -4824,7 +5320,7 @@ constexpr ParameterInfo kParameters[] = { { /* [597] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], + /* matcher indices */ &kMatcherIndices[0], }, { /* [598] */ @@ -4833,203 +5329,203 @@ constexpr ParameterInfo kParameters[] = { }, { /* [599] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[184], }, { /* [600] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kCoords, + /* matcher indices */ &kMatcherIndices[108], }, { /* [601] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[0], }, { /* [602] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [603] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[0], }, { /* [604] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[1], }, { /* [605] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[0], }, { /* [606] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [607] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[0], }, { /* [608] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [609] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[31], }, { /* [610] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[31], }, { /* [611] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[132], }, { /* [612] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[121], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [613] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[35], + /* matcher indices */ &kMatcherIndices[5], }, { /* [614] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[35], + /* matcher indices */ &kMatcherIndices[5], }, { /* [615] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[136], }, { /* [616] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [617] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[0], }, { /* [618] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[1], }, { /* [619] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[35], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[138], }, { /* [620] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[35], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [621] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[0], }, { /* [622] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [623] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[142], }, { /* [624] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [625] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[0], }, { /* [626] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[1], }, { /* [627] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[144], }, { /* [628] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [629] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[0], }, { /* [630] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [631] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[148], }, { /* [632] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [633] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [634] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [635] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [636] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [637] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], }, { /* [638] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [639] */ @@ -5039,22 +5535,22 @@ constexpr ParameterInfo kParameters[] = { { /* [640] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [641] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], }, { /* [642] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [643] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [644] */ @@ -5063,53 +5559,53 @@ constexpr ParameterInfo kParameters[] = { }, { /* [645] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], }, { /* [646] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [647] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[11], }, { /* [648] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[11], }, { /* [649] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], }, { /* [650] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kLevel, + /* matcher indices */ &kMatcherIndices[66], }, { /* [651] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [652] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [653] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[38], }, { /* [654] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[38], }, { /* [655] */ @@ -5119,252 +5615,252 @@ constexpr ParameterInfo kParameters[] = { { /* [656] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [657] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [658] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], + /* matcher indices */ &kMatcherIndices[38], }, { /* [659] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[31], }, { /* [660] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[59], + /* matcher indices */ &kMatcherIndices[31], }, { /* [661] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[5], }, { /* [662] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], + /* matcher indices */ &kMatcherIndices[5], }, { /* [663] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[11], }, { /* [664] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[11], }, { /* [665] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [666] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [667] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[148], - }, - { - /* [668] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[119], - }, - { - /* [669] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], - }, - { - /* [670] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], - }, - { - /* [671] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], - }, - { - /* [672] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], - }, - { - /* [673] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[129], - }, - { - /* [674] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[125], - }, - { - /* [675] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[117], - }, - { - /* [676] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], - }, - { - /* [677] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[107], - }, - { - /* [678] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[16], - }, - { - /* [679] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[103], - }, - { - /* [680] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[41], - }, - { - /* [681] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], - }, - { - /* [682] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], - }, - { - /* [683] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[129], - }, - { - /* [684] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], - }, - { - /* [685] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[150], - }, - { - /* [686] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[44], - }, - { - /* [687] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[41], - }, - { - /* [688] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[50], - }, - { - /* [689] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[53], - }, - { - /* [690] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[148], - }, - { - /* [691] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[146], - }, - { - /* [692] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[145], - }, - { - /* [693] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[144], - }, - { - /* [694] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[147], - }, - { - /* [695] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[119], - }, - { - /* [696] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[129], - }, - { - /* [697] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[125], - }, - { - /* [698] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[117], - }, - { - /* [699] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[111], - }, - { - /* [700] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[107], - }, - { - /* [701] */ - /* usage */ ParameterUsage::kTexture, - /* matcher indices */ &kMatcherIndices[103], - }, - { - /* [702] */ /* usage */ ParameterUsage::kNone, /* matcher indices */ &kMatcherIndices[38], }, { - /* [703] */ + /* [668] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [669] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [670] */ /* usage */ ParameterUsage::kNone, /* matcher indices */ &kMatcherIndices[1], }, + { + /* [671] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [672] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [673] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [674] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[11], + }, + { + /* [675] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[11], + }, + { + /* [676] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [677] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[11], + }, + { + /* [678] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [679] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [680] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [681] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [682] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [683] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [684] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [685] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [686] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [687] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[80], + }, + { + /* [688] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[11], + }, + { + /* [689] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[23], + }, + { + /* [690] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[15], + }, + { + /* [691] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [692] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [693] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [694] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [695] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [696] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [697] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [698] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [699] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [700] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[89], + }, + { + /* [701] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [702] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [703] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, { /* [704] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], + /* matcher indices */ &kMatcherIndices[38], }, { /* [705] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[1], + /* matcher indices */ &kMatcherIndices[38], }, { /* [706] */ @@ -5379,232 +5875,232 @@ constexpr ParameterInfo kParameters[] = { { /* [708] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [709] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[1], }, { /* [710] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [711] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [712] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [713] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[25], }, { /* [714] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[25], }, { /* [715] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[41], }, { /* [716] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[41], }, { /* [717] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [718] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[1], }, { /* [719] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [720] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [721] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[25], }, { /* [722] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[25], }, { /* [723] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[41], }, { /* [724] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[41], }, { /* [725] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [726] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [727] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [728] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [729] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[109], + /* matcher indices */ &kMatcherIndices[25], }, { /* [730] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[109], + /* matcher indices */ &kMatcherIndices[25], }, { /* [731] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[113], + /* matcher indices */ &kMatcherIndices[25], }, { /* [732] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[113], + /* matcher indices */ &kMatcherIndices[25], }, { /* [733] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[113], + /* matcher indices */ &kMatcherIndices[1], }, { /* [734] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [735] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [736] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [737] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [738] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [739] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[31], }, { /* [740] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[2], + /* matcher indices */ &kMatcherIndices[31], }, { /* [741] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [742] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [743] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [744] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[1], }, { /* [745] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [746] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [747] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [748] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[1], }, { /* [749] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [750] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [751] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[1], }, { /* [752] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[35], + /* matcher indices */ &kMatcherIndices[1], }, { /* [753] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[38], }, { /* [754] */ @@ -5614,52 +6110,52 @@ constexpr ParameterInfo kParameters[] = { { /* [755] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[1], }, { /* [756] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[1], }, { /* [757] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [758] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [759] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [760] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[35], }, { /* [761] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [762] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[92], }, { /* [763] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [764] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[35], }, { /* [765] */ @@ -5669,222 +6165,1032 @@ constexpr ParameterInfo kParameters[] = { { /* [766] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[92], }, { /* [767] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], }, { /* [768] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kY, + /* matcher indices */ &kMatcherIndices[1], }, { /* [769] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [770] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[35], }, { /* [771] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { /* [772] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[35], }, { /* [773] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[38], }, { /* [774] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[38], }, { /* [775] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[31], }, { /* [776] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[31], }, { /* [777] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[5], }, { /* [778] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[5], }, { /* [779] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kXy, + /* matcher indices */ &kMatcherIndices[104], }, { /* [780] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kZ, + /* matcher indices */ &kMatcherIndices[1], }, { /* [781] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], }, { /* [782] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kYz, + /* matcher indices */ &kMatcherIndices[104], }, { /* [783] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kXy, + /* matcher indices */ &kMatcherIndices[104], }, { /* [784] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[12], + /* usage */ ParameterUsage::kZw, + /* matcher indices */ &kMatcherIndices[104], }, { /* [785] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* usage */ ParameterUsage::kXyz, + /* matcher indices */ &kMatcherIndices[114], }, { /* [786] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* usage */ ParameterUsage::kW, + /* matcher indices */ &kMatcherIndices[1], }, { /* [787] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* usage */ ParameterUsage::kX, + /* matcher indices */ &kMatcherIndices[1], }, { /* [788] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* usage */ ParameterUsage::kZyw, + /* matcher indices */ &kMatcherIndices[114], }, { /* [789] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[98], }, { /* [790] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[98], }, { /* [791] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[38], + /* matcher indices */ &kMatcherIndices[118], }, { /* [792] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[3], + /* matcher indices */ &kMatcherIndices[118], }, { /* [793] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[31], }, { /* [794] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[31], }, { /* [795] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[5], }, { /* [796] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[5], }, { /* [797] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[100], }, { /* [798] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[100], }, { /* [799] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[118], }, { /* [800] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[118], }, { /* [801] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[1], }, { /* [802] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[1], }, { /* [803] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[7], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[185], }, { /* [804] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[35], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[150], }, { /* [805] */ - /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], }, { /* [806] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [807] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [808] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [809] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[148], + }, + { + /* [810] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[144], + }, + { + /* [811] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[142], + }, + { + /* [812] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[138], + }, + { + /* [813] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[136], + }, + { + /* [814] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[132], + }, + { + /* [815] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[56], + }, + { + /* [816] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], + }, + { + /* [817] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [818] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[148], + }, + { + /* [819] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[138], + }, + { + /* [820] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[184], + }, + { + /* [821] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[53], + }, + { + /* [822] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[56], + }, + { + /* [823] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[59], + }, + { + /* [824] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[62], + }, + { + /* [825] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[185], + }, + { + /* [826] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[181], + }, + { + /* [827] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[179], + }, + { + /* [828] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[182], + }, + { + /* [829] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[180], + }, + { + /* [830] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[150], + }, + { + /* [831] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[148], + }, + { + /* [832] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[144], + }, + { + /* [833] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[142], + }, + { + /* [834] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[138], + }, + { + /* [835] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[136], + }, + { + /* [836] */ + /* usage */ ParameterUsage::kTexture, + /* matcher indices */ &kMatcherIndices[132], + }, + { + /* [837] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [838] */ /* usage */ ParameterUsage::kNone, /* matcher indices */ &kMatcherIndices[35], }, { - /* [807] */ + /* [839] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[18], + /* matcher indices */ &kMatcherIndices[35], }, { - /* [808] */ + /* [840] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[32], + /* matcher indices */ &kMatcherIndices[35], }, { - /* [809] */ + /* [841] */ /* usage */ ParameterUsage::kNone, - /* matcher indices */ &kMatcherIndices[15], + /* matcher indices */ &kMatcherIndices[35], + }, + { + /* [842] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[35], + }, + { + /* [843] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [844] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [845] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[11], + }, + { + /* [846] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [847] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[0], + }, + { + /* [848] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [849] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [850] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [851] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [852] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [853] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [854] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [855] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [856] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [857] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [858] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[25], + }, + { + /* [859] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[41], + }, + { + /* [860] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [861] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [862] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [863] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [864] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [865] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [866] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [867] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [868] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [869] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [870] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [871] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [872] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [873] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [874] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[100], + }, + { + /* [875] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [876] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [877] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[98], + }, + { + /* [878] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [879] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [880] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [881] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [882] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [883] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[106], + }, + { + /* [884] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [885] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [886] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [887] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [888] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [889] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [890] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [891] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [892] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [893] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [894] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [895] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [896] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [897] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [898] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [899] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [900] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [901] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [902] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [903] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [904] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [905] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [906] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [907] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [908] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [909] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [910] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [911] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [912] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [913] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [914] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [915] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [916] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [917] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [918] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [919] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [920] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[66], + }, + { + /* [921] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [922] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[25], + }, + { + /* [923] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[35], + }, + { + /* [924] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [925] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[41], + }, + { + /* [926] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [927] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [928] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[25], + }, + { + /* [929] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[25], + }, + { + /* [930] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [931] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[41], + }, + { + /* [932] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[104], + }, + { + /* [933] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [934] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [935] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[106], + }, + { + /* [936] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [937] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[106], + }, + { + /* [938] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[106], + }, + { + /* [939] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[6], + }, + { + /* [940] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[114], + }, + { + /* [941] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [942] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[19], + }, + { + /* [943] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [944] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [945] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[116], + }, + { + /* [946] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[116], + }, + { + /* [947] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[116], + }, + { + /* [948] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[116], + }, + { + /* [949] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [950] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[128], + }, + { + /* [951] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [952] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [953] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [954] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [955] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [956] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[38], + }, + { + /* [957] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[1], + }, + { + /* [958] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [959] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[134], + }, + { + /* [960] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[134], + }, + { + /* [961] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[134], + }, + { + /* [962] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[134], + }, + { + /* [963] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [964] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [965] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [966] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [967] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [968] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [969] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], + }, + { + /* [970] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[5], + }, + { + /* [971] */ + /* usage */ ParameterUsage::kNone, + /* matcher indices */ &kMatcherIndices[31], }, }; @@ -5892,27 +7198,87 @@ constexpr OpenTypeInfo kOpenTypes[] = { { /* [0] */ /* name */ "T", - /* matcher index */ 36, + /* matcher index */ 2, }, { /* [1] */ - /* name */ "T", - /* matcher index */ 38, + /* name */ "U", + /* matcher index */ 53, }, { /* [2] */ /* name */ "T", - /* matcher index */ kNoMatcher, + /* matcher index */ 4, }, { /* [3] */ - /* name */ "T", - /* matcher index */ 39, + /* name */ "U", + /* matcher index */ 51, }, { /* [4] */ /* name */ "T", - /* matcher index */ 37, + /* matcher index */ 5, + }, + { + /* [5] */ + /* name */ "U", + /* matcher index */ 52, + }, + { + /* [6] */ + /* name */ "T", + /* matcher index */ 3, + }, + { + /* [7] */ + /* name */ "U", + /* matcher index */ 50, + }, + { + /* [8] */ + /* name */ "T", + /* matcher index */ 48, + }, + { + /* [9] */ + /* name */ "T", + /* matcher index */ 49, + }, + { + /* [10] */ + /* name */ "T", + /* matcher index */ 46, + }, + { + /* [11] */ + /* name */ "T", + /* matcher index */ kNoMatcher, + }, + { + /* [12] */ + /* name */ "T", + /* matcher index */ 53, + }, + { + /* [13] */ + /* name */ "T", + /* matcher index */ 50, + }, + { + /* [14] */ + /* name */ "T", + /* matcher index */ 52, + }, + { + /* [15] */ + /* name */ "T", + /* matcher index */ 51, + }, + { + /* [16] */ + /* name */ "T", + /* matcher index */ 47, }, }; @@ -5975,10 +7341,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[701], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[836], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -5986,10 +7352,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[533], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[611], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -5997,10 +7363,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[700], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[835], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6008,10 +7374,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[537], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[615], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6019,10 +7385,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[699], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[834], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6030,10 +7396,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[541], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[619], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6041,10 +7407,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[698], - /* return matcher indices */ &kMatcherIndices[95], + /* parameters */ &kParameters[833], + /* return matcher indices */ &kMatcherIndices[120], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6052,10 +7418,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[545], - /* return matcher indices */ &kMatcherIndices[95], + /* parameters */ &kParameters[623], + /* return matcher indices */ &kMatcherIndices[120], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6063,10 +7429,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[697], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[832], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6074,10 +7440,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[549], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[627], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6085,10 +7451,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[696], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[831], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6096,10 +7462,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[553], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[631], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6107,10 +7473,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[695], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[830], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6118,10 +7484,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[694], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[828], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6129,10 +7495,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[559], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[637], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6140,10 +7506,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[693], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[827], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6151,10 +7517,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[563], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[641], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6162,10 +7528,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[692], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[829], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6173,10 +7539,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[567], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[645], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6184,10 +7550,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[691], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[826], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6195,10 +7561,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[571], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[649], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6206,10 +7572,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[690], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[825], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6217,10 +7583,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[3], - /* parameters */ &kParameters[689], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[824], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6228,10 +7594,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[3], - /* parameters */ &kParameters[688], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[823], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6239,10 +7605,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[3], - /* parameters */ &kParameters[687], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[822], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6250,10 +7616,10 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[3], - /* parameters */ &kParameters[686], - /* return matcher indices */ &kMatcherIndices[95], + /* parameters */ &kParameters[821], + /* return matcher indices */ &kMatcherIndices[120], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -6261,504 +7627,504 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[685], - /* return matcher indices */ &kMatcherIndices[99], + /* parameters */ &kParameters[820], + /* return matcher indices */ &kMatcherIndices[108], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [27] */ - /* num parameters */ 3, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[443], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[379], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [28] */ - /* num parameters */ 3, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[455], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [29] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[330], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [30] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[334], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [31] */ /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[148], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[155], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [29] */ + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[160], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [30] */ + /* num parameters */ 6, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[138], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [31] */ + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[395], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [32] */ - /* num parameters */ 3, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[377], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[165], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [33] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[318], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[411], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [34] */ - /* num parameters */ 3, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[434], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[235], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [35] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[314], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[419], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [36] */ - /* num parameters */ 3, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[431], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[175], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [37] */ - /* num parameters */ 4, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[302], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[285], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [38] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[298], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [39] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[78], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [40] */ - /* num parameters */ 3, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[419], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [41] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[290], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), - }, - { - /* [42] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[326], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [43] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[183], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [44] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[193], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [45] */ /* num parameters */ 6, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[19], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[102], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { - /* [46] */ + /* [39] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[342], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[347], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { - /* [47] */ + /* [40] */ /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[213], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[210], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, + { + /* [41] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[510], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [42] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[468], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [43] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[474], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [44] */ + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[327], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [45] */ + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[311], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [46] */ + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[280], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [47] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[447], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, { /* [48] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[278], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[299], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [49] */ - /* num parameters */ 5, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[108], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[486], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [50] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[274], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[367], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [51] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[168], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [52] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[173], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [53] */ - /* num parameters */ 6, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[31], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [54] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[282], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [55] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[128], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [56] */ /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[437], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[495], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [52] */ + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[307], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [53] */ + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[315], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [54] */ + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[270], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [55] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[498], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [56] */ + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[319], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [57] */ - /* num parameters */ 4, + /* num parameters */ 0, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[222], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [58] */ - /* num parameters */ 5, + /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[203], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[950], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [59] */ - /* num parameters */ 5, + /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[208], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[951], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [60] */ - /* num parameters */ 6, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[49], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [61] */ /* num parameters */ 4, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[218], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[363], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [61] */ + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[9], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[516], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [62] */ - /* num parameters */ 5, + /* num parameters */ 3, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[198], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[531], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [63] */ /* num parameters */ 3, - /* num open types */ 0, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[371], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[543], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [64] */ - /* num parameters */ 4, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[226], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[783], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [65] */ - /* num parameters */ 4, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[230], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[785], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [66] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[178], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[787], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [67] */ - /* num parameters */ 3, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 2, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[6], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[374], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[959], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [68] */ - /* num parameters */ 4, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 2, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[2], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[234], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[960], + /* return matcher indices */ &kMatcherIndices[140], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [69] */ - /* num parameters */ 3, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 2, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[4], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[446], - /* return matcher indices */ nullptr, - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[961], + /* return matcher indices */ &kMatcherIndices[146], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [70] */ - /* num parameters */ 3, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 2, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[0], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[461], - /* return matcher indices */ nullptr, - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[962], + /* return matcher indices */ &kMatcherIndices[152], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [71] */ - /* num parameters */ 4, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[250], + /* parameters */ &kParameters[513], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, @@ -6767,20 +8133,20 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[473], + /* parameters */ &kParameters[519], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [73] */ - /* num parameters */ 3, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[350], + /* parameters */ &kParameters[371], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, @@ -6789,20 +8155,20 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[458], + /* parameters */ &kParameters[489], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [75] */ - /* num parameters */ 4, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[322], + /* parameters */ &kParameters[534], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, @@ -6811,20 +8177,20 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[452], + /* parameters */ &kParameters[540], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [77] */ - /* num parameters */ 3, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[476], + /* parameters */ &kParameters[391], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, @@ -6833,20 +8199,20 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[440], + /* parameters */ &kParameters[561], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [79] */ - /* num parameters */ 4, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[306], + /* parameters */ &kParameters[564], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, @@ -6855,637 +8221,637 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[428], + /* parameters */ &kParameters[567], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [81] */ - /* num parameters */ 1, - /* num open types */ 1, + /* num parameters */ 4, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[679], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[295], + /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [82] */ - /* num parameters */ 1, - /* num open types */ 1, + /* num parameters */ 3, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[677], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[573], + /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [83] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[676], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[303], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [84] */ - /* num parameters */ 1, + /* num parameters */ 5, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[675], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[215], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [85] */ - /* num parameters */ 1, + /* num parameters */ 5, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[674], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[275], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [86] */ - /* num parameters */ 1, + /* num parameters */ 6, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[673], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[132], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [87] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 4, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[672], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[323], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [88] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 5, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[671], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[255], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [89] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[670], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[471], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [90] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[669], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[335], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [91] */ - /* num parameters */ 3, - /* num open types */ 1, + /* num parameters */ 4, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[425], - /* return matcher indices */ &kMatcherIndices[105], + /* parameters */ &kParameters[351], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [92] */ - /* num parameters */ 3, - /* num open types */ 1, + /* num parameters */ 5, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[422], - /* return matcher indices */ &kMatcherIndices[105], + /* parameters */ &kParameters[205], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [93] */ - /* num parameters */ 4, - /* num open types */ 1, + /* num parameters */ 3, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[294], - /* return matcher indices */ &kMatcherIndices[105], + /* parameters */ &kParameters[450], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [94] */ - /* num parameters */ 3, - /* num open types */ 1, + /* num parameters */ 4, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[416], - /* return matcher indices */ &kMatcherIndices[105], + /* parameters */ &kParameters[359], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [95] */ - /* num parameters */ 3, + /* num parameters */ 0, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[413], - /* return matcher indices */ &kMatcherIndices[105], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[114], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [96] */ - /* num parameters */ 3, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[410], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[940], + /* return matcher indices */ &kMatcherIndices[114], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [97] */ - /* num parameters */ 4, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[286], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[941], + /* return matcher indices */ &kMatcherIndices[114], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [98] */ /* num parameters */ 3, - /* num open types */ 0, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[386], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[504], + /* return matcher indices */ &kMatcherIndices[114], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [99] */ /* num parameters */ 2, - /* num open types */ 0, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[493], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[779], + /* return matcher indices */ &kMatcherIndices[114], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [100] */ /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[665], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[781], + /* return matcher indices */ &kMatcherIndices[114], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [101] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[551], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[6], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[945], + /* return matcher indices */ &kMatcherIndices[118], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [102] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[555], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[2], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[946], + /* return matcher indices */ &kMatcherIndices[120], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [103] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[557], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[4], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[947], + /* return matcher indices */ &kMatcherIndices[124], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [104] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[561], - /* return matcher indices */ &kMatcherIndices[16], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[0], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[948], + /* return matcher indices */ &kMatcherIndices[126], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [105] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[565], - /* return matcher indices */ &kMatcherIndices[16], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[814], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [106] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[1], - /* parameters */ &kParameters[569], - /* return matcher indices */ &kMatcherIndices[47], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[813], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [107] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[1], - /* parameters */ &kParameters[573], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[812], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [108] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 3, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[0], - /* parameters */ &kParameters[575], - /* return matcher indices */ &kMatcherIndices[28], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[811], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [109] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[103], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[810], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [110] */ - /* num parameters */ 6, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[67], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[809], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [111] */ - /* num parameters */ 6, + /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[7], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[808], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [112] */ - /* num parameters */ 7, + /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[0], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[807], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [113] */ - /* num parameters */ 5, + /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[93], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[806], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [114] */ - /* num parameters */ 6, + /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[43], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[805], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [115] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[143], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[665], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [116] */ - /* num parameters */ 6, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[25], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[667], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [117] */ - /* num parameters */ 4, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[346], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[669], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [118] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[88], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[671], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [119] */ - /* num parameters */ 5, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[113], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[673], + /* return matcher indices */ &kMatcherIndices[11], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [120] */ - /* num parameters */ 6, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[55], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[675], + /* return matcher indices */ &kMatcherIndices[11], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [121] */ - /* num parameters */ 4, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[270], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[1], + /* parameters */ &kParameters[677], + /* return matcher indices */ &kMatcherIndices[80], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [122] */ - /* num parameters */ 5, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[73], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[1], + /* parameters */ &kParameters[687], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [123] */ - /* num parameters */ 4, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[266], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 3, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[0], + /* parameters */ &kParameters[689], + /* return matcher indices */ &kMatcherIndices[27], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [124] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 3, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[123], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[576], + /* return matcher indices */ &kMatcherIndices[128], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [125] */ - /* num parameters */ 4, - /* num open types */ 0, + /* num parameters */ 3, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[246], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[579], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [126] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 4, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[153], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[415], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [127] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 3, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[138], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[585], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [128] */ - /* num parameters */ 6, - /* num open types */ 0, + /* num parameters */ 3, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[37], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[501], + /* return matcher indices */ &kMatcherIndices[128], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [129] */ - /* num parameters */ 4, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[262], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[492], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [130] */ - /* num parameters */ 5, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[118], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[423], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [131] */ - /* num parameters */ 4, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[242], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[588], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [132] */ - /* num parameters */ 5, + /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[158], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[599], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [133] */ - /* num parameters */ 5, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[83], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [134] */ - /* num parameters */ 6, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[61], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - }, - { - /* [135] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[254], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[331], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { - /* [136] */ + /* [134] */ /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[133], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[250], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [135] */ + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[245], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + }, + { + /* [136] */ + /* num parameters */ 6, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[78], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [137] */ /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[258], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[343], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { @@ -7493,670 +8859,670 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[188], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[225], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [139] */ - /* num parameters */ 5, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[98], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[399], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [140] */ - /* num parameters */ 6, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[13], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[265], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [141] */ - /* num parameters */ 4, - /* num open types */ 0, + /* num parameters */ 0, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[238], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[104], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [142] */ - /* num parameters */ 5, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[163], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[932], + /* return matcher indices */ &kMatcherIndices[104], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [143] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[531], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[933], + /* return matcher indices */ &kMatcherIndices[104], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [144] */ /* num parameters */ 2, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[535], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[9], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[767], + /* return matcher indices */ &kMatcherIndices[104], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [145] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[539], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[6], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[935], + /* return matcher indices */ &kMatcherIndices[98], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [146] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[543], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[2], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[883], + /* return matcher indices */ &kMatcherIndices[108], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [147] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[547], - /* return matcher indices */ &kMatcherIndices[16], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 2, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[4], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[937], + /* return matcher indices */ &kMatcherIndices[110], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [148] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 1, + /* num open types */ 2, /* num open numbers */ 0, /* open types */ &kOpenTypes[0], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[521], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[938], + /* return matcher indices */ &kMatcherIndices[112], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [149] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[523], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[240], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [150] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[525], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 6, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[114], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [151] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[527], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 6, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[90], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [152] */ - /* num parameters */ 2, + /* num parameters */ 7, /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[529], - /* return matcher indices */ &kMatcherIndices[16], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[65], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [153] */ - /* num parameters */ 1, - /* num open types */ 1, + /* num parameters */ 5, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[684], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[190], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [154] */ - /* num parameters */ 1, - /* num open types */ 1, + /* num parameters */ 6, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[683], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[108], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [155] */ - /* num parameters */ 1, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[682], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[230], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [156] */ - /* num parameters */ 1, + /* num parameters */ 6, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[681], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[72], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [157] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[3], - /* parameters */ &kParameters[680], - /* return matcher indices */ &kMatcherIndices[58], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[407], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [158] */ - /* num parameters */ 2, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[617], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[170], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [159] */ - /* num parameters */ 2, + /* num parameters */ 5, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[619], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[185], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [160] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 6, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[621], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[84], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [161] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[623], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[443], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [162] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 5, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[577], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[195], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [163] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[579], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[355], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [164] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[583], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[200], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [165] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[585], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[150], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [166] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 6, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[587], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[126], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [167] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[589], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[375], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [168] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[591], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 5, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[220], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [169] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[593], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[387], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [170] */ - /* num parameters */ 2, + /* num parameters */ 5, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[609], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[180], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [171] */ - /* num parameters */ 2, + /* num parameters */ 5, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[613], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[260], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [172] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 6, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[615], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[120], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [173] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[663], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 4, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[427], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [174] */ - /* num parameters */ 3, - /* num open types */ 1, + /* num parameters */ 5, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[3], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[464], - /* return matcher indices */ &kMatcherIndices[3], + /* parameters */ &kParameters[290], + /* return matcher indices */ &kMatcherIndices[100], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [175] */ - /* num parameters */ 3, + /* num parameters */ 1, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[3], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[467], - /* return matcher indices */ &kMatcherIndices[38], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[819], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [176] */ - /* num parameters */ 3, + /* num parameters */ 1, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[3], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[470], - /* return matcher indices */ &kMatcherIndices[38], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[818], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [177] */ - /* num parameters */ 3, + /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[401], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[817], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [178] */ - /* num parameters */ 3, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[404], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[816], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [179] */ - /* num parameters */ 3, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[407], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[3], + /* parameters */ &kParameters[815], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [180] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[764], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[651], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [181] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[763], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[653], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [182] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[781], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[655], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [183] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[780], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[657], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [184] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[779], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[663], + /* return matcher indices */ &kMatcherIndices[11], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [185] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[778], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[633], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [186] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[809], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[635], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [187] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[777], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[639], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [188] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[776], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[643], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [189] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[775], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[647], + /* return matcher indices */ &kMatcherIndices[11], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [190] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[774], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[713], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [191] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[773], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[715], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [192] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[8], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[772], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[717], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [193] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[8], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[771], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[719], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [194] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[770], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[697], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [195] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[769], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[703], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [196] */ - /* num parameters */ 3, + /* num parameters */ 2, /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[368], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[705], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [197] */ - /* num parameters */ 3, + /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[365], + /* parameters */ &kParameters[707], /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [198] */ /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[3], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[629], - /* return matcher indices */ &kMatcherIndices[18], + /* parameters */ &kParameters[801], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -8164,1682 +9530,1682 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[3], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[631], - /* return matcher indices */ &kMatcherIndices[35], + /* parameters */ &kParameters[691], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [200] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[768], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[693], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [201] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[767], + /* parameters */ &kParameters[695], /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [202] */ - /* num parameters */ 1, - /* num open types */ 1, + /* num parameters */ 2, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[766], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[721], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [203] */ - /* num parameters */ 1, - /* num open types */ 1, + /* num parameters */ 2, + /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[765], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[723], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [204] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[8], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[783], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[725], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [205] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[8], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[782], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[727], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [206] */ - /* num parameters */ 3, + /* num parameters */ 0, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[359], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[158], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [207] */ - /* num parameters */ 3, + /* num parameters */ 9, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[356], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[40], + /* return matcher indices */ &kMatcherIndices[158], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [208] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[762], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[582], + /* return matcher indices */ &kMatcherIndices[158], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [209] */ - /* num parameters */ 1, + /* num parameters */ 0, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[761], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[4], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [210] */ - /* num parameters */ 1, + /* num parameters */ 8, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[760], - /* return matcher indices */ &kMatcherIndices[152], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[49], + /* return matcher indices */ &kMatcherIndices[4], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [211] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[759], - /* return matcher indices */ &kMatcherIndices[137], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[797], + /* return matcher indices */ &kMatcherIndices[4], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [212] */ - /* num parameters */ 1, + /* num parameters */ 0, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[758], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[156], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [213] */ - /* num parameters */ 1, + /* num parameters */ 6, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[757], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[96], + /* return matcher indices */ &kMatcherIndices[156], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [214] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[750], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[570], + /* return matcher indices */ &kMatcherIndices[156], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [215] */ - /* num parameters */ 1, + /* num parameters */ 0, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[749], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[130], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [216] */ - /* num parameters */ 1, + /* num parameters */ 16, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[748], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* parameters */ &kParameters[0], + /* return matcher indices */ &kMatcherIndices[130], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [217] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[747], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[339], + /* return matcher indices */ &kMatcherIndices[130], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [218] */ - /* num parameters */ 4, - /* num open types */ 1, + /* num parameters */ 0, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[338], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [219] */ - /* num parameters */ 4, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[310], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[920], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [220] */ /* num parameters */ 1, - /* num open types */ 0, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[15], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[746], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[921], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [221] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[745], - /* return matcher indices */ &kMatcherIndices[32], + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[9], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[522], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [222] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[507], - /* return matcher indices */ &kMatcherIndices[15], + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[9], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[525], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [223] */ - /* num parameters */ 2, - /* num open types */ 0, + /* num parameters */ 3, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[509], - /* return matcher indices */ &kMatcherIndices[32], + /* parameters */ &kParameters[528], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [224] */ - /* num parameters */ 1, + /* num parameters */ 0, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[744], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [225] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[743], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[923], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [226] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[3], + /* open types */ &kOpenTypes[14], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[633], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[924], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [227] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[3], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[639], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 0, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [228] */ /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[739], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[926], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [229] */ /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[738], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[13], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[927], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [230] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 0, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[491], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[36], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [231] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[581], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 6, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[144], + /* return matcher indices */ &kMatcherIndices[36], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [232] */ /* num parameters */ 2, - /* num open types */ 1, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[489], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[791], + /* return matcher indices */ &kMatcherIndices[36], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [233] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[487], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 0, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [234] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 1, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[641], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[929], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [235] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[643], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[12], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[930], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [236] */ - /* num parameters */ 1, + /* num parameters */ 0, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[736], - /* return matcher indices */ &kMatcherIndices[151], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[160], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [237] */ - /* num parameters */ 1, + /* num parameters */ 12, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[735], - /* return matcher indices */ &kMatcherIndices[115], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[16], + /* return matcher indices */ &kMatcherIndices[160], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [238] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 3, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[645], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[591], + /* return matcher indices */ &kMatcherIndices[160], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [239] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[647], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 0, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[162], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [240] */ - /* num parameters */ 2, + /* num parameters */ 8, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[603], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[57], + /* return matcher indices */ &kMatcherIndices[162], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [241] */ - /* num parameters */ 2, + /* num parameters */ 4, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[601], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[431], + /* return matcher indices */ &kMatcherIndices[162], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [242] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 0, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[605], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[164], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [243] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[607], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 12, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[28], + /* return matcher indices */ &kMatcherIndices[164], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [244] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 4, + /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[649], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[435], + /* return matcher indices */ &kMatcherIndices[164], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [245] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[651], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 0, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ &kMatcherIndices[154], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [246] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[786], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[383], + /* return matcher indices */ &kMatcherIndices[154], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [247] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[785], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[789], + /* return matcher indices */ &kMatcherIndices[154], + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [248] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[742], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[459], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [249] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[741], - /* return matcher indices */ &kMatcherIndices[32], + /* parameters */ &kParameters[462], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [250] */ - /* num parameters */ 2, + /* num parameters */ 3, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[485], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[465], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [251] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[483], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[858], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [252] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[728], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[859], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [253] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[727], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[893], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [254] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[653], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[892], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [255] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[655], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[895], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [256] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[788], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[894], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [257] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[787], - /* return matcher indices */ &kMatcherIndices[38], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[439], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [258] */ - /* num parameters */ 1, + /* num parameters */ 4, /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[726], - /* return matcher indices */ &kMatcherIndices[3], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[403], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [259] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[725], - /* return matcher indices */ &kMatcherIndices[38], + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[889], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [260] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[724], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[888], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [261] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[723], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[701], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [262] */ - /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[790], - /* return matcher indices */ &kMatcherIndices[3], + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[699], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [263] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[789], - /* return matcher indices */ &kMatcherIndices[38], + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[887], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [264] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[792], - /* return matcher indices */ &kMatcherIndices[3], + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[886], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [265] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[791], - /* return matcher indices */ &kMatcherIndices[38], + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[885], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [266] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[720], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[884], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [267] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[719], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[882], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [268] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[718], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[881], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [269] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[717], - /* return matcher indices */ &kMatcherIndices[32], + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[685], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [270] */ - /* num parameters */ 3, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[398], - /* return matcher indices */ &kMatcherIndices[15], + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[683], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [271] */ - /* num parameters */ 3, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[395], - /* return matcher indices */ &kMatcherIndices[32], + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[681], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [272] */ - /* num parameters */ 3, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[389], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kIsDeprecated), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[679], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [273] */ - /* num parameters */ 3, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[383], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kIsDeprecated), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[897], + /* return matcher indices */ &kMatcherIndices[187], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [274] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[716], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[969], + /* return matcher indices */ &kMatcherIndices[122], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [275] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[715], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[880], + /* return matcher indices */ &kMatcherIndices[186], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [276] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[499], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[879], + /* return matcher indices */ &kMatcherIndices[102], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [277] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[501], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[899], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [278] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[4], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[755], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[898], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [279] */ - /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[4], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[756], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[456], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [280] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[713], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[453], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [281] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[712], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[891], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [282] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[711], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[890], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [283] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[710], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[901], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [284] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[753], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[900], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [285] */ /* num parameters */ 1, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[754], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[903], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [286] */ /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[709], - /* return matcher indices */ &kMatcherIndices[15], + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[902], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [287] */ /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[708], - /* return matcher indices */ &kMatcherIndices[32], + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[905], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [288] */ /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[751], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[904], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [289] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[752], - /* return matcher indices */ &kMatcherIndices[35], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[661], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [290] */ /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[661], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[659], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [291] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[479], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[872], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [292] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[796], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[871], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [293] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[795], - /* return matcher indices */ &kMatcherIndices[32], + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[483], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [294] */ /* num parameters */ 3, /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[392], - /* return matcher indices */ &kMatcherIndices[3], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[480], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [295] */ - /* num parameters */ 3, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[380], - /* return matcher indices */ &kMatcherIndices[38], + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[906], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [296] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[798], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[966], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [297] */ /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[797], - /* return matcher indices */ &kMatcherIndices[32], + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[869], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [298] */ - /* num parameters */ 2, - /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[637], - /* return matcher indices */ &kMatcherIndices[15], + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[868], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [299] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[635], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[867], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [300] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[800], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[866], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [301] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[799], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[908], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [302] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[802], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[907], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [303] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[801], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[865], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [304] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[657], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[864], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [305] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[659], - /* return matcher indices */ &kMatcherIndices[38], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[857], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [306] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[805], - /* return matcher indices */ &kMatcherIndices[18], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[856], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [307] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[804], - /* return matcher indices */ &kMatcherIndices[18], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[855], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [308] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[807], - /* return matcher indices */ &kMatcherIndices[18], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[854], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [309] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[806], - /* return matcher indices */ &kMatcherIndices[18], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[549], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [310] */ - /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[668], - /* return matcher indices */ &kMatcherIndices[58], + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[552], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [311] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[667], - /* return matcher indices */ &kMatcherIndices[58], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[555], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kIsDeprecated), }, { /* [312] */ - /* num parameters */ 1, + /* num parameters */ 3, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[714], - /* return matcher indices */ &kMatcherIndices[15], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[558], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kIsDeprecated), }, { /* [313] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[808], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[853], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [314] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[794], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[852], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [315] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[793], - /* return matcher indices */ &kMatcherIndices[32], + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[613], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [316] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[722], - /* return matcher indices */ &kMatcherIndices[15], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[609], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [317] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[721], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[910], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [318] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[737], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[909], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [319] */ /* num parameters */ 1, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[702], - /* return matcher indices */ &kMatcherIndices[38], + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[850], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [320] */ - /* num parameters */ 0, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[810], - /* return matcher indices */ nullptr, - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[849], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [321] */ /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[704], - /* return matcher indices */ &kMatcherIndices[109], + /* parameters */ &kParameters[848], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [322] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[705], - /* return matcher indices */ &kMatcherIndices[113], + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[846], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [323] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[8], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[706], - /* return matcher indices */ &kMatcherIndices[113], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[763], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [324] */ - /* num parameters */ 1, + /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[740], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[765], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [325] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[495], - /* return matcher indices */ nullptr, - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[844], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [326] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 1, + /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[497], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[843], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [327] */ /* num parameters */ 2, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[503], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[759], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [328] */ /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[505], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[761], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [329] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[511], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[912], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [330] */ - /* num parameters */ 2, - /* num open types */ 1, + /* num parameters */ 1, + /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[513], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[911], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [331] */ /* num parameters */ 2, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[515], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[751], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [332] */ /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[517], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[753], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [333] */ /* num parameters */ 2, /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[519], - /* return matcher indices */ &kMatcherIndices[3], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[747], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [334] */ - /* num parameters */ 3, + /* num parameters */ 2, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[1], - /* open numbers */ &kOpenNumbers[9], - /* parameters */ &kParameters[353], - /* return matcher indices */ &kMatcherIndices[135], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[749], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [335] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[707], - /* return matcher indices */ &kMatcherIndices[113], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[743], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [336] */ - /* num parameters */ 1, - /* num open types */ 0, - /* num open numbers */ 2, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[5], - /* parameters */ &kParameters[678], - /* return matcher indices */ &kMatcherIndices[20], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[745], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [337] */ - /* num parameters */ 1, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[703], - /* return matcher indices */ &kMatcherIndices[109], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[737], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [338] */ - /* num parameters */ 3, - /* num open types */ 0, + /* num parameters */ 2, + /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[9], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[449], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[741], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [339] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[481], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[914], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [340] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[729], - /* return matcher indices */ &kMatcherIndices[1], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[913], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [341] */ /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[730], - /* return matcher indices */ &kMatcherIndices[1], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[916], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [342] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[731], - /* return matcher indices */ &kMatcherIndices[1], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[915], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [343] */ /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[732], - /* return matcher indices */ &kMatcherIndices[1], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[918], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [344] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[733], - /* return matcher indices */ &kMatcherIndices[1], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[917], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [345] */ /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[734], - /* return matcher indices */ &kMatcherIndices[32], - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[936], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [346] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, - /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], - /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[625], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[934], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), }, { /* [347] */ /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[627], - /* return matcher indices */ &kMatcherIndices[18], - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* parameters */ &kParameters[777], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [348] */ - /* num parameters */ 3, + /* num parameters */ 2, /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[362], - /* return matcher indices */ &kMatcherIndices[32], + /* parameters */ &kParameters[775], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [349] */ - /* num parameters */ 2, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[10], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[595], - /* return matcher indices */ &kMatcherIndices[1], + /* parameters */ &kParameters[804], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [350] */ - /* num parameters */ 2, + /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[597], - /* return matcher indices */ &kMatcherIndices[58], + /* parameters */ &kParameters[803], + /* return matcher indices */ &kMatcherIndices[66], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [351] */ - /* num parameters */ 2, - /* num open types */ 1, - /* num open numbers */ 1, - /* open types */ &kOpenTypes[0], - /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[599], - /* return matcher indices */ &kMatcherIndices[3], + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[944], + /* return matcher indices */ &kMatcherIndices[5], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -9847,21 +11213,21 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 0, /* num open numbers */ 1, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[6], - /* parameters */ &kParameters[784], - /* return matcher indices */ &kMatcherIndices[15], + /* parameters */ &kParameters[971], + /* return matcher indices */ &kMatcherIndices[31], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [353] */ - /* num parameters */ 2, - /* num open types */ 0, + /* num parameters */ 1, + /* num open types */ 1, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[8], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[611], - /* return matcher indices */ &kMatcherIndices[121], + /* parameters */ &kParameters[953], + /* return matcher indices */ &kMatcherIndices[1], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { @@ -9869,23 +11235,804 @@ constexpr OverloadInfo kOverloads[] = { /* num parameters */ 1, /* num open types */ 1, /* num open numbers */ 1, - /* open types */ &kOpenTypes[2], - /* open numbers */ &kOpenNumbers[8], - /* parameters */ &kParameters[803], - /* return matcher indices */ &kMatcherIndices[1], + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[952], + /* return matcher indices */ &kMatcherIndices[38], /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), }, { /* [355] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[9], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[733], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [356] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[9], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[735], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [357] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[955], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [358] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[954], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [359] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[957], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [360] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[956], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [361] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[964], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [362] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[958], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [363] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[967], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [364] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[965], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [365] */ + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[594], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [366] */ + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[546], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [367] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[970], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [368] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[968], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [369] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[795], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [370] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[793], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [371] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[709], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [372] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[711], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [373] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[963], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [374] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[896], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [375] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[943], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [376] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[949], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [377] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[928], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [378] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[931], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [379] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[922], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [380] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[925], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [381] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[851], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [382] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[919], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [383] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[16], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[862], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [384] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[16], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[863], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [385] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[860], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [386] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[861], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [387] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[870], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [388] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[837], + /* return matcher indices */ &kMatcherIndices[38], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [389] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[755], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [390] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[757], + /* return matcher indices */ &kMatcherIndices[41], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [391] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[841], + /* return matcher indices */ &kMatcherIndices[98], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [392] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[597], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [393] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[625], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [394] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[621], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [395] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[617], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [396] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[607], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [397] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[605], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [398] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[603], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [399] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[601], + /* return matcher indices */ nullptr, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [400] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[847], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [401] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[729], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [402] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[731], + /* return matcher indices */ &kMatcherIndices[25], + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [403] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[875], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [404] */ /* num parameters */ 0, /* num open types */ 0, /* num open numbers */ 0, - /* open types */ &kOpenTypes[5], + /* open types */ &kOpenTypes[17], /* open numbers */ &kOpenNumbers[10], - /* parameters */ &kParameters[810], + /* parameters */ &kParameters[972], /* return matcher indices */ nullptr, /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), }, + { + /* [405] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[838], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [406] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[839], + /* return matcher indices */ &kMatcherIndices[100], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [407] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[840], + /* return matcher indices */ &kMatcherIndices[98], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [408] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[629], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [409] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[842], + /* return matcher indices */ &kMatcherIndices[98], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [410] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 2, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[5], + /* parameters */ &kParameters[845], + /* return matcher indices */ &kMatcherIndices[15], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [411] */ + /* num parameters */ 0, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[972], + /* return matcher indices */ nullptr, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [412] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[507], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [413] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[739], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [414] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[873], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [415] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[874], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [416] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[876], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [417] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[877], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [418] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[878], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [419] */ + /* num parameters */ 3, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[477], + /* return matcher indices */ &kMatcherIndices[31], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [420] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[769], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [421] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[771], + /* return matcher indices */ &kMatcherIndices[66], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [422] */ + /* num parameters */ 2, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[10], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[773], + /* return matcher indices */ &kMatcherIndices[1], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [423] */ + /* num parameters */ 1, + /* num open types */ 0, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[6], + /* parameters */ &kParameters[942], + /* return matcher indices */ &kMatcherIndices[5], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [424] */ + /* num parameters */ 2, + /* num open types */ 0, + /* num open numbers */ 0, + /* open types */ &kOpenTypes[17], + /* open numbers */ &kOpenNumbers[10], + /* parameters */ &kParameters[799], + /* return matcher indices */ &kMatcherIndices[118], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [425] */ + /* num parameters */ 1, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[11], + /* open numbers */ &kOpenNumbers[8], + /* parameters */ &kParameters[939], + /* return matcher indices */ &kMatcherIndices[35], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, + { + /* [426] */ + /* num parameters */ 3, + /* num open types */ 1, + /* num open numbers */ 1, + /* open types */ &kOpenTypes[8], + /* open numbers */ &kOpenNumbers[9], + /* parameters */ &kParameters[537], + /* return matcher indices */ &kMatcherIndices[104], + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + }, }; constexpr IntrinsicInfo kBuiltins[] = { @@ -9894,336 +12041,336 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn abs(T) -> T */ /* fn abs(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[318], + /* overloads */ &kOverloads[387], }, { /* [1] */ /* fn acos(f32) -> f32 */ /* fn acos(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[312], + /* overloads */ &kOverloads[381], }, { /* [2] */ /* fn all(bool) -> bool */ /* fn all(vec) -> bool */ /* num overloads */ 2, - /* overloads */ &kOverloads[308], + /* overloads */ &kOverloads[379], }, { /* [3] */ /* fn any(bool) -> bool */ /* fn any(vec) -> bool */ /* num overloads */ 2, - /* overloads */ &kOverloads[306], + /* overloads */ &kOverloads[377], }, { /* [4] */ /* fn arrayLength(ptr, A>) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[354], + /* overloads */ &kOverloads[425], }, { /* [5] */ /* fn asin(f32) -> f32 */ /* fn asin(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[302], + /* overloads */ &kOverloads[375], }, { /* [6] */ /* fn atan(f32) -> f32 */ /* fn atan(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[300], + /* overloads */ &kOverloads[373], }, { /* [7] */ /* fn atan2(f32, f32) -> f32 */ /* fn atan2(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[298], + /* overloads */ &kOverloads[369], }, { /* [8] */ /* fn ceil(f32) -> f32 */ /* fn ceil(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[296], + /* overloads */ &kOverloads[367], }, { /* [9] */ /* fn clamp(T, T, T) -> T */ /* fn clamp(vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[294], + /* overloads */ &kOverloads[365], }, { /* [10] */ /* fn cos(f32) -> f32 */ /* fn cos(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[292], + /* overloads */ &kOverloads[363], }, { /* [11] */ /* fn cosh(f32) -> f32 */ /* fn cosh(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[314], + /* overloads */ &kOverloads[361], }, { /* [12] */ /* fn countLeadingZeros(T) -> T */ /* fn countLeadingZeros(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[264], + /* overloads */ &kOverloads[359], }, { /* [13] */ /* fn countOneBits(T) -> T */ /* fn countOneBits(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[262], + /* overloads */ &kOverloads[357], }, { /* [14] */ /* fn countTrailingZeros(T) -> T */ /* fn countTrailingZeros(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[256], + /* overloads */ &kOverloads[353], }, { /* [15] */ /* fn cross(vec3, vec3) -> vec3 */ /* num overloads */ 1, - /* overloads */ &kOverloads[353], + /* overloads */ &kOverloads[424], }, { /* [16] */ /* fn degrees(f32) -> f32 */ /* fn degrees(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[246], + /* overloads */ &kOverloads[351], }, { /* [17] */ /* fn determinant(mat) -> f32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[352], + /* overloads */ &kOverloads[423], }, { /* [18] */ /* fn distance(f32, f32) -> f32 */ /* fn distance(vec, vec) -> f32 */ /* num overloads */ 2, - /* overloads */ &kOverloads[240], + /* overloads */ &kOverloads[347], }, { /* [19] */ /* fn dot(vec, vec) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[351], + /* overloads */ &kOverloads[422], }, { /* [20] */ /* fn dot4I8Packed(u32, u32) -> i32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[350], + /* overloads */ &kOverloads[421], }, { /* [21] */ /* fn dot4U8Packed(u32, u32) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[349], + /* overloads */ &kOverloads[420], }, { /* [22] */ /* fn dpdx(f32) -> f32 */ /* fn dpdx(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[204], + /* overloads */ &kOverloads[345], }, { /* [23] */ /* fn dpdxCoarse(f32) -> f32 */ /* fn dpdxCoarse(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[182], + /* overloads */ &kOverloads[343], }, { /* [24] */ /* fn dpdxFine(f32) -> f32 */ /* fn dpdxFine(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[184], + /* overloads */ &kOverloads[341], }, { /* [25] */ /* fn dpdy(f32) -> f32 */ /* fn dpdy(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[186], + /* overloads */ &kOverloads[339], }, { /* [26] */ /* fn dpdyCoarse(f32) -> f32 */ /* fn dpdyCoarse(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[188], + /* overloads */ &kOverloads[329], }, { /* [27] */ /* fn dpdyFine(f32) -> f32 */ /* fn dpdyFine(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[190], + /* overloads */ &kOverloads[317], }, { /* [28] */ /* fn exp(f32) -> f32 */ /* fn exp(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[192], + /* overloads */ &kOverloads[301], }, { /* [29] */ /* fn exp2(f32) -> f32 */ /* fn exp2(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[194], + /* overloads */ &kOverloads[295], }, { /* [30] */ /* fn extractBits(T, u32, u32) -> T */ /* fn extractBits(vec, u32, u32) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[196], + /* overloads */ &kOverloads[293], }, { /* [31] */ /* fn faceForward(vec, vec, vec) -> vec */ /* num overloads */ 1, - /* overloads */ &kOverloads[348], + /* overloads */ &kOverloads[419], }, { /* [32] */ /* fn firstLeadingBit(T) -> T */ /* fn firstLeadingBit(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[200], + /* overloads */ &kOverloads[287], }, { /* [33] */ /* fn firstTrailingBit(T) -> T */ /* fn firstTrailingBit(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[202], + /* overloads */ &kOverloads[285], }, { /* [34] */ /* fn floor(f32) -> f32 */ /* fn floor(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[180], + /* overloads */ &kOverloads[283], }, { /* [35] */ /* fn fma(f32, f32, f32) -> f32 */ /* fn fma(vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[206], + /* overloads */ &kOverloads[279], }, { /* [36] */ /* fn fract(f32) -> f32 */ /* fn fract(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[208], + /* overloads */ &kOverloads[277], }, { /* [37] */ /* fn frexp(f32) -> __frexp_result */ /* fn frexp(vec) -> __frexp_result_vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[210], + /* overloads */ &kOverloads[273], }, { /* [38] */ /* fn fwidth(f32) -> f32 */ /* fn fwidth(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[212], + /* overloads */ &kOverloads[255], }, { /* [39] */ /* fn fwidthCoarse(f32) -> f32 */ /* fn fwidthCoarse(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[214], + /* overloads */ &kOverloads[253], }, { /* [40] */ /* fn fwidthFine(f32) -> f32 */ /* fn fwidthFine(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[216], + /* overloads */ &kOverloads[281], }, { /* [41] */ /* fn insertBits(T, T, u32, u32) -> T */ /* fn insertBits(vec, vec, u32, u32) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[218], + /* overloads */ &kOverloads[257], }, { /* [42] */ /* fn inverseSqrt(f32) -> f32 */ /* fn inverseSqrt(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[220], + /* overloads */ &kOverloads[259], }, { /* [43] */ /* fn ldexp(f32, i32) -> f32 */ /* fn ldexp(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[222], + /* overloads */ &kOverloads[261], }, { /* [44] */ /* fn length(f32) -> f32 */ /* fn length(vec) -> f32 */ /* num overloads */ 2, - /* overloads */ &kOverloads[224], + /* overloads */ &kOverloads[263], }, { /* [45] */ /* fn log(f32) -> f32 */ /* fn log(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[248], + /* overloads */ &kOverloads[265], }, { /* [46] */ /* fn log2(f32) -> f32 */ /* fn log2(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[228], + /* overloads */ &kOverloads[267], }, { /* [47] */ /* fn max(T, T) -> T */ /* fn max(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[230], + /* overloads */ &kOverloads[269], }, { /* [48] */ /* fn min(T, T) -> T */ /* fn min(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[232], + /* overloads */ &kOverloads[271], }, { /* [49] */ @@ -10231,90 +12378,90 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn mix(vec, vec, vec) -> vec */ /* fn mix(vec, vec, f32) -> vec */ /* num overloads */ 3, - /* overloads */ &kOverloads[177], + /* overloads */ &kOverloads[248], }, { /* [50] */ /* fn modf(f32) -> __modf_result */ /* fn modf(vec) -> __modf_result_vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[236], + /* overloads */ &kOverloads[275], }, { /* [51] */ /* fn normalize(vec) -> vec */ /* num overloads */ 1, - /* overloads */ &kOverloads[345], + /* overloads */ &kOverloads[418], }, { /* [52] */ /* fn pack2x16float(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[344], + /* overloads */ &kOverloads[417], }, { /* [53] */ /* fn pack2x16snorm(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[343], + /* overloads */ &kOverloads[416], }, { /* [54] */ /* fn pack2x16unorm(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[342], + /* overloads */ &kOverloads[403], }, { /* [55] */ /* fn pack4x8snorm(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[341], + /* overloads */ &kOverloads[415], }, { /* [56] */ /* fn pack4x8unorm(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ &kOverloads[340], + /* overloads */ &kOverloads[414], }, { /* [57] */ /* fn pow(f32, f32) -> f32 */ /* fn pow(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[250], + /* overloads */ &kOverloads[289], }, { /* [58] */ /* fn radians(f32) -> f32 */ /* fn radians(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[252], + /* overloads */ &kOverloads[291], }, { /* [59] */ /* fn reflect(vec, vec) -> vec */ /* num overloads */ 1, - /* overloads */ &kOverloads[339], + /* overloads */ &kOverloads[413], }, { /* [60] */ /* fn refract(vec, vec, f32) -> vec */ /* num overloads */ 1, - /* overloads */ &kOverloads[338], + /* overloads */ &kOverloads[412], }, { /* [61] */ /* fn reverseBits(T) -> T */ /* fn reverseBits(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[258], + /* overloads */ &kOverloads[297], }, { /* [62] */ /* fn round(f32) -> f32 */ /* fn round(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[260], + /* overloads */ &kOverloads[299], }, { /* [63] */ @@ -10322,125 +12469,125 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn select(vec, vec, bool) -> vec */ /* fn select(vec, vec, vec) -> vec */ /* num overloads */ 3, - /* overloads */ &kOverloads[174], + /* overloads */ &kOverloads[221], }, { /* [64] */ /* fn sign(f32) -> f32 */ /* fn sign(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[316], + /* overloads */ &kOverloads[303], }, { /* [65] */ /* fn sin(f32) -> f32 */ /* fn sin(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[266], + /* overloads */ &kOverloads[305], }, { /* [66] */ /* fn sinh(f32) -> f32 */ /* fn sinh(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[268], + /* overloads */ &kOverloads[307], }, { /* [67] */ /* fn smoothstep(f32, f32, f32) -> f32 */ /* fn smoothstep(vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[270], + /* overloads */ &kOverloads[309], }, { /* [68] */ /* fn smoothStep(f32, f32, f32) -> f32 */ /* fn smoothStep(vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[272], + /* overloads */ &kOverloads[311], }, { /* [69] */ /* fn sqrt(f32) -> f32 */ /* fn sqrt(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[274], + /* overloads */ &kOverloads[313], }, { /* [70] */ /* fn step(f32, f32) -> f32 */ /* fn step(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[276], + /* overloads */ &kOverloads[315], }, { /* [71] */ /* fn storageBarrier() */ /* num overloads */ 1, - /* overloads */ &kOverloads[320], + /* overloads */ &kOverloads[411], }, { /* [72] */ /* fn tan(f32) -> f32 */ /* fn tan(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[280], + /* overloads */ &kOverloads[319], }, { /* [73] */ /* fn tanh(f32) -> f32 */ /* fn tanh(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[282], + /* overloads */ &kOverloads[321], }, { /* [74] */ /* fn transpose(mat) -> mat */ /* num overloads */ 1, - /* overloads */ &kOverloads[336], + /* overloads */ &kOverloads[410], }, { /* [75] */ /* fn trunc(f32) -> f32 */ /* fn trunc(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[286], + /* overloads */ &kOverloads[325], }, { /* [76] */ /* fn unpack2x16float(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ &kOverloads[335], + /* overloads */ &kOverloads[409], }, { /* [77] */ /* fn unpack2x16snorm(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ &kOverloads[323], + /* overloads */ &kOverloads[391], }, { /* [78] */ /* fn unpack2x16unorm(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ &kOverloads[322], + /* overloads */ &kOverloads[407], }, { /* [79] */ /* fn unpack4x8snorm(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ &kOverloads[321], + /* overloads */ &kOverloads[406], }, { /* [80] */ /* fn unpack4x8unorm(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ &kOverloads[337], + /* overloads */ &kOverloads[405], }, { /* [81] */ /* fn workgroupBarrier() */ /* num overloads */ 1, - /* overloads */ &kOverloads[355], + /* overloads */ &kOverloads[404], }, { /* [82] */ @@ -10489,7 +12636,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> vec4 */ /* fn textureGather(texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: i32) -> vec4 */ /* num overloads */ 12, - /* overloads */ &kOverloads[57], + /* overloads */ &kOverloads[83], }, { /* [84] */ @@ -10500,7 +12647,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> vec4 */ /* fn textureGatherCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: i32, depth_ref: f32) -> vec4 */ /* num overloads */ 6, - /* overloads */ &kOverloads[131], + /* overloads */ &kOverloads[169], }, { /* [85] */ @@ -10510,7 +12657,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureNumLayers(texture: texture_depth_cube_array) -> i32 */ /* fn textureNumLayers(texture: texture_storage_2d_array) -> i32 */ /* num overloads */ 5, - /* overloads */ &kOverloads[153], + /* overloads */ &kOverloads[175], }, { /* [86] */ @@ -10525,14 +12672,14 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureNumLevels(texture: texture_depth_cube) -> i32 */ /* fn textureNumLevels(texture: texture_depth_cube_array) -> i32 */ /* num overloads */ 10, - /* overloads */ &kOverloads[81], + /* overloads */ &kOverloads[105], }, { /* [87] */ /* fn textureNumSamples(texture: texture_multisampled_2d) -> i32 */ /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> i32 */ /* num overloads */ 2, - /* overloads */ &kOverloads[310], + /* overloads */ &kOverloads[349], }, { /* [88] */ @@ -10552,7 +12699,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> f32 */ /* fn textureSample(texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: i32) -> f32 */ /* num overloads */ 15, - /* overloads */ &kOverloads[27], + /* overloads */ &kOverloads[42], }, { /* [89] */ @@ -10565,7 +12712,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleBias(texture: texture_cube, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ /* fn textureSampleBias(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32, bias: f32) -> vec4 */ /* num overloads */ 8, - /* overloads */ &kOverloads[117], + /* overloads */ &kOverloads[133], }, { /* [90] */ @@ -10576,7 +12723,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 */ /* fn textureSampleCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: i32, depth_ref: f32) -> f32 */ /* num overloads */ 6, - /* overloads */ &kOverloads[137], + /* overloads */ &kOverloads[163], }, { /* [91] */ @@ -10587,7 +12734,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 */ /* fn textureSampleCompareLevel(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: i32, depth_ref: f32) -> f32 */ /* num overloads */ 6, - /* overloads */ &kOverloads[125], + /* overloads */ &kOverloads[157], }, { /* [92] */ @@ -10600,7 +12747,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleGrad(texture: texture_cube, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ /* fn textureSampleGrad(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32, ddx: vec3, ddy: vec3) -> vec4 */ /* num overloads */ 8, - /* overloads */ &kOverloads[109], + /* overloads */ &kOverloads[149], }, { /* [93] */ @@ -10620,7 +12767,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleLevel(texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: i32, level: i32) -> f32 */ /* fn textureSampleLevel(texture: texture_external, sampler: sampler, coords: vec2) -> vec4 */ /* num overloads */ 15, - /* overloads */ &kOverloads[42], + /* overloads */ &kOverloads[27], }, { /* [94] */ @@ -10637,7 +12784,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureStore(texture: texture_storage_2d_array, coords: vec2, array_index: i32, value: vec4) */ /* fn textureStore(texture: texture_storage_3d, coords: vec3, value: vec4) */ /* num overloads */ 12, - /* overloads */ &kOverloads[69], + /* overloads */ &kOverloads[71], }, { /* [95] */ @@ -10651,73 +12798,73 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureLoad(texture: texture_depth_multisampled_2d, coords: vec2, sample_index: i32) -> f32 */ /* fn textureLoad(texture: texture_external, coords: vec2) -> vec4 */ /* num overloads */ 9, - /* overloads */ &kOverloads[91], + /* overloads */ &kOverloads[124], }, { /* [96] */ /* fn atomicLoad(ptr, read_write>) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[324], + /* overloads */ &kOverloads[400], }, { /* [97] */ /* fn atomicStore(ptr, read_write>, T) */ /* num overloads */ 1, - /* overloads */ &kOverloads[325], + /* overloads */ &kOverloads[399], }, { /* [98] */ /* fn atomicAdd(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[326], + /* overloads */ &kOverloads[398], }, { /* [99] */ /* fn atomicSub(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[327], + /* overloads */ &kOverloads[397], }, { /* [100] */ /* fn atomicMax(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[328], + /* overloads */ &kOverloads[396], }, { /* [101] */ /* fn atomicMin(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[329], + /* overloads */ &kOverloads[395], }, { /* [102] */ /* fn atomicAnd(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[330], + /* overloads */ &kOverloads[394], }, { /* [103] */ /* fn atomicOr(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[331], + /* overloads */ &kOverloads[393], }, { /* [104] */ /* fn atomicXor(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[332], + /* overloads */ &kOverloads[392], }, { /* [105] */ /* fn atomicExchange(ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ &kOverloads[333], + /* overloads */ &kOverloads[408], }, { /* [106] */ /* fn atomicCompareExchangeWeak(ptr, read_write>, T, T) -> vec2 */ /* num overloads */ 1, - /* overloads */ &kOverloads[334], + /* overloads */ &kOverloads[426], }, }; @@ -10727,21 +12874,21 @@ constexpr IntrinsicInfo kUnaryOperators[] = { /* op !(bool) -> bool */ /* op !(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[288], + /* overloads */ &kOverloads[251], }, { /* [1] */ /* op ~(T) -> T */ /* op ~(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[284], + /* overloads */ &kOverloads[385], }, { /* [2] */ /* op -(T) -> T */ /* op -(vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[278], + /* overloads */ &kOverloads[383], }, }; constexpr uint8_t kUnaryOperatorNot = 0; @@ -10757,7 +12904,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op +(T, vec) -> vec */ /* op +(mat, mat) -> mat */ /* num overloads */ 5, - /* overloads */ &kOverloads[148], + /* overloads */ &kOverloads[185], }, { /* [1] */ @@ -10767,7 +12914,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op -(T, vec) -> vec */ /* op -(mat, mat) -> mat */ /* num overloads */ 5, - /* overloads */ &kOverloads[143], + /* overloads */ &kOverloads[180], }, { /* [2] */ @@ -10781,7 +12928,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op *(vec, mat) -> vec */ /* op *(mat, mat) -> mat */ /* num overloads */ 9, - /* overloads */ &kOverloads[100], + /* overloads */ &kOverloads[115], }, { /* [3] */ @@ -10790,7 +12937,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op /(vec, T) -> vec */ /* op /(T, vec) -> vec */ /* num overloads */ 4, - /* overloads */ &kOverloads[162], + /* overloads */ &kOverloads[198], }, { /* [4] */ @@ -10799,14 +12946,14 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op %(vec, T) -> vec */ /* op %(T, vec) -> vec */ /* num overloads */ 4, - /* overloads */ &kOverloads[166], + /* overloads */ &kOverloads[194], }, { /* [5] */ /* op ^(T, T) -> T */ /* op ^(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[242], + /* overloads */ &kOverloads[371], }, { /* [6] */ @@ -10815,7 +12962,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op &(T, T) -> T */ /* op &(vec, vec) -> vec */ /* num overloads */ 4, - /* overloads */ &kOverloads[170], + /* overloads */ &kOverloads[190], }, { /* [7] */ @@ -10824,75 +12971,75 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op |(T, T) -> T */ /* op |(vec, vec) -> vec */ /* num overloads */ 4, - /* overloads */ &kOverloads[158], + /* overloads */ &kOverloads[202], }, { /* [8] */ /* op &&(bool, bool) -> bool */ /* num overloads */ 1, - /* overloads */ &kOverloads[346], + /* overloads */ &kOverloads[401], }, { /* [9] */ /* op ||(bool, bool) -> bool */ /* num overloads */ 1, - /* overloads */ &kOverloads[347], + /* overloads */ &kOverloads[402], }, { /* [10] */ /* op ==(T, T) -> bool */ /* op ==(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[198], + /* overloads */ &kOverloads[355], }, { /* [11] */ /* op !=(T, T) -> bool */ /* op !=(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[226], + /* overloads */ &kOverloads[337], }, { /* [12] */ /* op <(T, T) -> bool */ /* op <(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[234], + /* overloads */ &kOverloads[335], }, { /* [13] */ /* op >(T, T) -> bool */ /* op >(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[238], + /* overloads */ &kOverloads[333], }, { /* [14] */ /* op <=(T, T) -> bool */ /* op <=(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[244], + /* overloads */ &kOverloads[331], }, { /* [15] */ /* op >=(T, T) -> bool */ /* op >=(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[254], + /* overloads */ &kOverloads[389], }, { /* [16] */ /* op <<(T, u32) -> T */ /* op <<(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[304], + /* overloads */ &kOverloads[327], }, { /* [17] */ /* op >>(T, u32) -> T */ /* op >>(vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ &kOverloads[290], + /* overloads */ &kOverloads[323], }, }; constexpr uint8_t kBinaryOperatorPlus = 0; @@ -10914,4 +13061,158 @@ constexpr uint8_t kBinaryOperatorGreaterThanEqual = 15; constexpr uint8_t kBinaryOperatorShiftLeft = 16; constexpr uint8_t kBinaryOperatorShiftRight = 17; +constexpr IntrinsicInfo kConstructorsAndConverters[] = { + { + /* [0] */ + /* ctor i32() -> i32 */ + /* ctor i32(i32) -> i32 */ + /* conv i32(T) -> i32 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[218], + }, + { + /* [1] */ + /* ctor u32() -> u32 */ + /* ctor u32(u32) -> u32 */ + /* conv u32(T) -> u32 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[224], + }, + { + /* [2] */ + /* ctor f32() -> f32 */ + /* ctor f32(f32) -> f32 */ + /* conv f32(T) -> f32 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[227], + }, + { + /* [3] */ + /* ctor bool() -> bool */ + /* ctor bool(bool) -> bool */ + /* conv bool(T) -> bool */ + /* num overloads */ 3, + /* overloads */ &kOverloads[233], + }, + { + /* [4] */ + /* ctor vec2() -> vec2 */ + /* ctor vec2(vec2) -> vec2 */ + /* ctor vec2(T) -> vec2 */ + /* ctor vec2(x: T, y: T) -> vec2 */ + /* conv vec2(vec2) -> vec2 */ + /* conv vec2(vec2) -> vec2 */ + /* conv vec2(vec2) -> vec2 */ + /* conv vec2(vec2) -> vec2 */ + /* num overloads */ 8, + /* overloads */ &kOverloads[141], + }, + { + /* [5] */ + /* ctor vec3() -> vec3 */ + /* ctor vec3(vec3) -> vec3 */ + /* ctor vec3(T) -> vec3 */ + /* ctor vec3(x: T, y: T, z: T) -> vec3 */ + /* ctor vec3(xy: vec2, z: T) -> vec3 */ + /* ctor vec3(x: T, yz: vec2) -> vec3 */ + /* conv vec3(vec3) -> vec3 */ + /* conv vec3(vec3) -> vec3 */ + /* conv vec3(vec3) -> vec3 */ + /* conv vec3(vec3) -> vec3 */ + /* num overloads */ 10, + /* overloads */ &kOverloads[95], + }, + { + /* [6] */ + /* ctor vec4() -> vec4 */ + /* ctor vec4(vec4) -> vec4 */ + /* ctor vec4(T) -> vec4 */ + /* ctor vec4(x: T, y: T, z: T, w: T) -> vec4 */ + /* ctor vec4(xy: vec2, z: T, w: T) -> vec4 */ + /* ctor vec4(x: T, yz: vec2, w: T) -> vec4 */ + /* ctor vec4(x: T, y: T, zw: vec2) -> vec4 */ + /* ctor vec4(xy: vec2, zw: vec2) -> vec4 */ + /* ctor vec4(xyz: vec3, w: T) -> vec4 */ + /* ctor vec4(x: T, zyw: vec3) -> vec4 */ + /* conv vec4(vec4) -> vec4 */ + /* conv vec4(vec4) -> vec4 */ + /* conv vec4(vec4) -> vec4 */ + /* conv vec4(vec4) -> vec4 */ + /* num overloads */ 14, + /* overloads */ &kOverloads[57], + }, + { + /* [7] */ + /* ctor mat2x2() -> mat2x2 */ + /* ctor mat2x2(f32, f32, f32, f32) -> mat2x2 */ + /* ctor mat2x2(vec2, vec2) -> mat2x2 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[245], + }, + { + /* [8] */ + /* ctor mat2x3() -> mat2x3 */ + /* ctor mat2x3(f32, f32, f32, f32, f32, f32) -> mat2x3 */ + /* ctor mat2x3(vec3, vec3) -> mat2x3 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[230], + }, + { + /* [9] */ + /* ctor mat2x4() -> mat2x4 */ + /* ctor mat2x4(f32, f32, f32, f32, f32, f32, f32, f32) -> mat2x4 */ + /* ctor mat2x4(vec4, vec4) -> mat2x4 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[209], + }, + { + /* [10] */ + /* ctor mat3x2() -> mat3x2 */ + /* ctor mat3x2(f32, f32, f32, f32, f32, f32) -> mat3x2 */ + /* ctor mat3x2(vec2, vec2, vec2) -> mat3x2 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[212], + }, + { + /* [11] */ + /* ctor mat3x3() -> mat3x3 */ + /* ctor mat3x3(f32, f32, f32, f32, f32, f32, f32, f32, f32) -> mat3x3 */ + /* ctor mat3x3(vec3, vec3, vec3) -> mat3x3 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[206], + }, + { + /* [12] */ + /* ctor mat3x4() -> mat3x4 */ + /* ctor mat3x4(f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32) -> mat3x4 */ + /* ctor mat3x4(vec4, vec4, vec4) -> mat3x4 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[236], + }, + { + /* [13] */ + /* ctor mat4x2() -> mat4x2 */ + /* ctor mat4x2(f32, f32, f32, f32, f32, f32, f32, f32) -> mat4x2 */ + /* ctor mat4x2(vec2, vec2, vec2, vec2) -> mat4x2 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[239], + }, + { + /* [14] */ + /* ctor mat4x3() -> mat4x3 */ + /* ctor mat4x3(f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32) -> mat4x3 */ + /* ctor mat4x3(vec3, vec3, vec3, vec3) -> mat4x3 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[242], + }, + { + /* [15] */ + /* ctor mat4x4() -> mat4x4 */ + /* ctor mat4x4(f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32) -> mat4x4 */ + /* ctor mat4x4(vec4, vec4, vec4, vec4) -> mat4x4 */ + /* num overloads */ 3, + /* overloads */ &kOverloads[215], + }, +}; + // clang-format on diff --git a/src/tint/resolver/intrinsic_table.inl.tmpl b/src/tint/resolver/intrinsic_table.inl.tmpl index 961be33ae6..86d91df060 100644 --- a/src/tint/resolver/intrinsic_table.inl.tmpl +++ b/src/tint/resolver/intrinsic_table.inl.tmpl @@ -153,6 +153,19 @@ constexpr IntrinsicInfo kBinaryOperators[] = { constexpr uint8_t kBinaryOperator{{template "OperatorName" $o.Name}} = {{$i}}; {{- end }} +constexpr IntrinsicInfo kConstructorsAndConverters[] = { +{{- range $i, $o := .ConstructorsAndConverters }} + { + /* [{{$i}}] */ +{{- range $o.OverloadDescriptions }} + /* {{.}} */ +{{- end }} + /* num overloads */ {{$o.NumOverloads}}, + /* overloads */ &kOverloads[{{$o.OverloadsOffset}}], + }, +{{- end }} +}; + // clang-format on {{ end -}} diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc index bec7a490da..206c951881 100644 --- a/src/tint/resolver/intrinsic_table_test.cc +++ b/src/tint/resolver/intrinsic_table_test.cc @@ -26,6 +26,8 @@ #include "src/tint/sem/reference.h" #include "src/tint/sem/sampled_texture.h" #include "src/tint/sem/storage_texture.h" +#include "src/tint/sem/type_constructor.h" +#include "src/tint/sem/type_conversion.h" namespace tint::resolver { namespace { @@ -663,6 +665,118 @@ TEST_F(IntrinsicTableTest, MismatchCompoundOp) { )"); } +TEST_F(IntrinsicTableTest, MatchTypeConstructorImplicit) { + auto* i32 = create(); + auto* vec3_i32 = create(i32, 3u); + auto* result = + table->Lookup(CtorConvIntrinsic::kVec3, nullptr, {i32, i32, i32}, Source{{12, 34}}); + ASSERT_NE(result, nullptr); + EXPECT_EQ(result->ReturnType(), vec3_i32); + EXPECT_TRUE(result->Is()); + ASSERT_EQ(result->Parameters().size(), 3u); + EXPECT_EQ(result->Parameters()[0]->Type(), i32); + EXPECT_EQ(result->Parameters()[1]->Type(), i32); + EXPECT_EQ(result->Parameters()[2]->Type(), i32); +} + +TEST_F(IntrinsicTableTest, MatchTypeConstructorExplicit) { + auto* i32 = create(); + auto* vec3_i32 = create(i32, 3u); + auto* result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {i32, i32, i32}, Source{{12, 34}}); + ASSERT_NE(result, nullptr); + EXPECT_EQ(result->ReturnType(), vec3_i32); + EXPECT_TRUE(result->Is()); + ASSERT_EQ(result->Parameters().size(), 3u); + EXPECT_EQ(result->Parameters()[0]->Type(), i32); + EXPECT_EQ(result->Parameters()[1]->Type(), i32); + EXPECT_EQ(result->Parameters()[2]->Type(), i32); +} + +TEST_F(IntrinsicTableTest, MismatchTypeConstructorImplicit) { + auto* i32 = create(); + auto* f32 = create(); + auto* result = + table->Lookup(CtorConvIntrinsic::kVec3, nullptr, {i32, f32, i32}, Source{{12, 34}}); + ASSERT_EQ(result, nullptr); + EXPECT_EQ(Diagnostics().str(), R"(12:34 error: no matching constructor for vec3(i32, f32, i32) + +6 candidate constructors: + vec3(x: T, y: T, z: T) -> vec3 where: T is f32, i32, u32 or bool + vec3(xy: vec2, z: T) -> vec3 where: T is f32, i32, u32 or bool + vec3(x: T, yz: vec2) -> vec3 where: T is f32, i32, u32 or bool + vec3(T) -> vec3 where: T is f32, i32, u32 or bool + vec3(vec3) -> vec3 where: T is f32, i32, u32 or bool + vec3() -> vec3 where: T is f32, i32, u32 or bool + +4 candidate conversions: + vec3(vec3) -> vec3 where: T is f32, U is i32, u32 or bool + vec3(vec3) -> vec3 where: T is i32, U is f32, u32 or bool + vec3(vec3) -> vec3 where: T is u32, U is f32, i32 or bool + vec3(vec3) -> vec3 where: T is bool, U is f32, i32 or u32 +)"); +} + +TEST_F(IntrinsicTableTest, MismatchTypeConstructorExplicit) { + auto* i32 = create(); + auto* f32 = create(); + auto* result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {i32, f32, i32}, Source{{12, 34}}); + ASSERT_EQ(result, nullptr); + EXPECT_EQ(Diagnostics().str(), + R"(12:34 error: no matching constructor for vec3(i32, f32, i32) + +6 candidate constructors: + vec3(x: T, y: T, z: T) -> vec3 where: T is f32, i32, u32 or bool + vec3(x: T, yz: vec2) -> vec3 where: T is f32, i32, u32 or bool + vec3(T) -> vec3 where: T is f32, i32, u32 or bool + vec3(xy: vec2, z: T) -> vec3 where: T is f32, i32, u32 or bool + vec3(vec3) -> vec3 where: T is f32, i32, u32 or bool + vec3() -> vec3 where: T is f32, i32, u32 or bool + +4 candidate conversions: + vec3(vec3) -> vec3 where: T is f32, U is i32, u32 or bool + vec3(vec3) -> vec3 where: T is i32, U is f32, u32 or bool + vec3(vec3) -> vec3 where: T is u32, U is f32, i32 or bool + vec3(vec3) -> vec3 where: T is bool, U is f32, i32 or u32 +)"); +} + +TEST_F(IntrinsicTableTest, MatchTypeConversion) { + auto* i32 = create(); + auto* vec3_i32 = create(i32, 3u); + auto* f32 = create(); + auto* vec3_f32 = create(f32, 3u); + auto* result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {vec3_f32}, Source{{12, 34}}); + ASSERT_NE(result, nullptr); + EXPECT_EQ(result->ReturnType(), vec3_i32); + EXPECT_TRUE(result->Is()); + ASSERT_EQ(result->Parameters().size(), 1u); + EXPECT_EQ(result->Parameters()[0]->Type(), vec3_f32); +} + +TEST_F(IntrinsicTableTest, MismatchTypeConversion) { + auto* arr = create(create(), 0u, 4u, 4u, 4u, 4u); + auto* f32 = create(); + auto* result = table->Lookup(CtorConvIntrinsic::kVec3, f32, {arr}, Source{{12, 34}}); + ASSERT_EQ(result, nullptr); + EXPECT_EQ(Diagnostics().str(), + R"(12:34 error: no matching constructor for vec3(array) + +6 candidate constructors: + vec3(vec3) -> vec3 where: T is f32, i32, u32 or bool + vec3(T) -> vec3 where: T is f32, i32, u32 or bool + vec3() -> vec3 where: T is f32, i32, u32 or bool + vec3(xy: vec2, z: T) -> vec3 where: T is f32, i32, u32 or bool + vec3(x: T, yz: vec2) -> vec3 where: T is f32, i32, u32 or bool + vec3(x: T, y: T, z: T) -> vec3 where: T is f32, i32, u32 or bool + +4 candidate conversions: + vec3(vec3) -> vec3 where: T is f32, U is i32, u32 or bool + vec3(vec3) -> vec3 where: T is i32, U is f32, u32 or bool + vec3(vec3) -> vec3 where: T is u32, U is f32, i32 or bool + vec3(vec3) -> vec3 where: T is bool, U is f32, i32 or u32 +)"); +} + TEST_F(IntrinsicTableTest, Err257Arguments) { // crbug.com/1323605 auto* f32 = create(); std::vector arg_tys(257, f32); diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc index 38a502587d..9d4ee16dea 100644 --- a/src/tint/resolver/resolver.cc +++ b/src/tint/resolver/resolver.cc @@ -1148,155 +1148,186 @@ sem::Expression* Resolver::Bitcast(const ast::BitcastExpression* expr) { } sem::Call* Resolver::Call(const ast::CallExpression* expr) { + // A CallExpression can resolve to one of: + // * A function call. + // * A builtin call. + // * A type constructor. + // * A type conversion. + + // Resolve all of the arguments, their types and the set of behaviors. std::vector args(expr->args.size()); - std::vector arg_tys(args.size()); + std::vector arg_tys(expr->args.size()); sem::Behaviors arg_behaviors; - - // The element type of all the arguments. Nullptr if argument types are - // different. - const sem::Type* arg_el_ty = nullptr; - for (size_t i = 0; i < expr->args.size(); i++) { auto* arg = sem_.Get(expr->args[i]); if (!arg) { return nullptr; } args[i] = arg; - arg_tys[i] = args[i]->Type(); + arg_tys[i] = arg->Type(); arg_behaviors.Add(arg->Behaviors()); - - // Determine the common argument element type - auto* el_ty = arg_tys[i]->UnwrapRef(); - if (auto* vec = el_ty->As()) { - el_ty = vec->type(); - } else if (auto* mat = el_ty->As()) { - el_ty = mat->type(); - } - if (i == 0) { - arg_el_ty = el_ty; - } else if (arg_el_ty != el_ty) { - arg_el_ty = nullptr; - } } - arg_behaviors.Remove(sem::Behavior::kNext); - auto type_ctor_or_conv = [&](const sem::Type* ty) -> sem::Call* { - // The call has resolved to a type constructor or cast. - if (args.size() == 1) { - auto* target = ty; - auto* source = args[0]->Type()->UnwrapRef(); - if ((source != target) && // - ((source->is_scalar() && target->is_scalar()) || - (source->Is() && target->Is()) || - (source->Is() && target->Is()))) { - // Note: Matrix types currently cannot be converted (the element type - // must only be f32). We implement this for the day we support other - // matrix element types. - return TypeConversion(expr, ty, args[0], arg_tys[0]); - } - } - return TypeConstructor(expr, ty, std::move(args), std::move(arg_tys)); + // Did any arguments have side effects? + bool has_side_effects = + std::any_of(args.begin(), args.end(), [](auto* e) { return e->HasSideEffects(); }); + + // array_or_struct_ctor is a helper for building a sem::TypeConstructor call for an array or + // structure type. These types have constructors that are always explicitly typed (no + // inference), and do not support type conversion. As such, they do not use the IntrinsicTable. + auto array_or_struct_ctor = [&](const sem::Type* ty) -> sem::Call* { + auto* call_target = utils::GetOrCreate( + type_ctors_, TypeConstructorSig{ty, arg_tys}, [&]() -> sem::TypeConstructor* { + return builder_->create( + ty, utils::Transform( + arg_tys, [&](const sem::Type* t, size_t i) -> const sem::Parameter* { + return builder_->create( + nullptr, // declaration + static_cast(i), // index + t->UnwrapRef(), // type + ast::StorageClass::kNone, // storage_class + ast::Access::kUndefined); // access + })); + }); + auto value = EvaluateConstantValue(expr, ty); + return builder_->create(expr, call_target, std::move(args), current_statement_, + value, has_side_effects); }; - // Resolve the target of the CallExpression to determine whether this is a - // function call, cast or type constructor expression. - if (expr->target.type) { - const sem::Type* ty = nullptr; - - auto err_cannot_infer_el_ty = [&](std::string name) { - AddError("cannot infer " + name + - " element type, as constructor arguments have different types", - expr->source); - for (size_t i = 0; i < args.size(); i++) { - auto* arg = args[i]; - AddNote("argument " + std::to_string(i) + " has type " + - arg->Type()->FriendlyName(builder_->Symbols()), - arg->Declaration()->source); - } - }; - - if (!expr->args.empty()) { - // vecN() without explicit element type? - // Try to infer element type from args - if (auto* vec = expr->target.type->As()) { - if (!vec->type) { - if (!arg_el_ty) { - err_cannot_infer_el_ty("vector"); - return nullptr; - } - - Mark(vec); - auto* v = - builder_->create(arg_el_ty, static_cast(vec->width)); - if (!validator_.Vector(v, vec->source)) { - return nullptr; - } - builder_->Sem().Add(vec, v); - ty = v; - } - } - - // matNxM() without explicit element type? - // Try to infer element type from args - if (auto* mat = expr->target.type->As()) { - if (!mat->type) { - if (!arg_el_ty) { - err_cannot_infer_el_ty("matrix"); - return nullptr; - } - - Mark(mat); - auto* column_type = builder_->create(arg_el_ty, mat->rows); - auto* m = builder_->create(column_type, mat->columns); - if (!validator_.Matrix(m, mat->source)) { - return nullptr; - } - builder_->Sem().Add(mat, m); - ty = m; - } - } + // ct_ctor_or_conv is a helper for building either a sem::TypeConstructor or sem::TypeConversion + // call for a CtorConvIntrinsic with an optional template argument type. + auto ct_ctor_or_conv = [&](CtorConvIntrinsic ty, const sem::Type* template_arg) -> sem::Call* { + auto* call_target = intrinsic_table_->Lookup(ty, template_arg, arg_tys, expr->source); + if (!call_target) { + return nullptr; } + auto value = EvaluateConstantValue(expr, call_target->ReturnType()); + return builder_->create(expr, call_target, std::move(args), current_statement_, + value, has_side_effects); + }; - if (ty == nullptr) { - ty = Type(expr->target.type); - if (!ty) { + // ct_ctor_or_conv is a helper for building either a sem::TypeConstructor or sem::TypeConversion + // call for the given semantic type. + auto ty_ctor_or_conv = [&](const sem::Type* ty) { + return Switch( + ty, // + [&](const sem::Vector* v) { + return ct_ctor_or_conv(VectorCtorConvIntrinsic(v->Width()), v->type()); + }, + [&](const sem::Matrix* m) { + return ct_ctor_or_conv(MatrixCtorConvIntrinsic(m->columns(), m->rows()), m->type()); + }, + [&](const sem::I32*) { return ct_ctor_or_conv(CtorConvIntrinsic::kI32, nullptr); }, + [&](const sem::U32*) { return ct_ctor_or_conv(CtorConvIntrinsic::kU32, nullptr); }, + [&](const sem::F32*) { return ct_ctor_or_conv(CtorConvIntrinsic::kF32, nullptr); }, + [&](const sem::Bool*) { return ct_ctor_or_conv(CtorConvIntrinsic::kBool, nullptr); }, + [&](const sem::Array*) { return array_or_struct_ctor(ty); }, + [&](const sem::Struct*) { return array_or_struct_ctor(ty); }, + [&](Default) { + AddError("type is not constructible", expr->source); return nullptr; - } - } + }); + }; - return type_ctor_or_conv(ty); + // ast::CallExpression has a target which is either an ast::Type or an ast::IdentifierExpression + sem::Call* call = nullptr; + if (expr->target.type) { + // ast::CallExpression has an ast::Type as the target. + // This call is either a type constructor or type conversion. + call = Switch( + expr->target.type, + [&](const ast::Vector* v) -> sem::Call* { + Mark(v); + // vector element type must be inferred if it was not specified. + sem::Type* template_arg = nullptr; + if (v->type) { + template_arg = Type(v->type); + if (!template_arg) { + return nullptr; + } + } + if (auto* c = ct_ctor_or_conv(VectorCtorConvIntrinsic(v->width), template_arg)) { + builder_->Sem().Add(expr->target.type, c->Target()->ReturnType()); + return c; + } + return nullptr; + }, + [&](const ast::Matrix* m) -> sem::Call* { + Mark(m); + // matrix element type must be inferred if it was not specified. + sem::Type* template_arg = nullptr; + if (m->type) { + template_arg = Type(m->type); + if (!template_arg) { + return nullptr; + } + } + if (auto* c = ct_ctor_or_conv(MatrixCtorConvIntrinsic(m->columns, m->rows), + template_arg)) { + builder_->Sem().Add(expr->target.type, c->Target()->ReturnType()); + return c; + } + return nullptr; + }, + [&](const ast::Type* ast) -> sem::Call* { + // Handler for AST types that do not have an optional element type. + if (auto* ty = Type(ast)) { + return ty_ctor_or_conv(ty); + } + return nullptr; + }, + [&](Default) { + TINT_ICE(Resolver, diagnostics_) + << expr->source << " unhandled CallExpression target:\n" + << "type: " + << (expr->target.type ? expr->target.type->TypeInfo().name : ""); + return nullptr; + }); + } else { + // ast::CallExpression has an ast::IdentifierExpression as the target. + // This call is either a function call, builtin call, type constructor or type conversion. + auto* ident = expr->target.name; + Mark(ident); + auto* resolved = sem_.ResolvedSymbol(ident); + call = Switch( + resolved, // + [&](sem::Type* ty) { + // A type constructor or conversions. + // Note: Unlike the codepath where we're resolving the call target from an + // ast::Type, all types must already have the element type explicitly specified, so + // there's no need to infer element types. + return ty_ctor_or_conv(ty); + }, + [&](sem::Function* func) { + return FunctionCall(expr, func, std::move(args), arg_behaviors); + }, + [&](sem::Variable* var) { + auto name = builder_->Symbols().NameFor(var->Declaration()->symbol); + AddError("cannot call variable '" + name + "'", ident->source); + AddNote("'" + name + "' declared here", var->Declaration()->source); + return nullptr; + }, + [&](Default) -> sem::Call* { + auto name = builder_->Symbols().NameFor(ident->symbol); + auto builtin_type = sem::ParseBuiltinType(name); + if (builtin_type != sem::BuiltinType::kNone) { + return BuiltinCall(expr, builtin_type, std::move(args), std::move(arg_tys)); + } + + TINT_ICE(Resolver, diagnostics_) + << expr->source << " unhandled CallExpression target:\n" + << "resolved: " << (resolved ? resolved->TypeInfo().name : "") << "\n" + << "name: " << builder_->Symbols().NameFor(ident->symbol); + return nullptr; + }); } - auto* ident = expr->target.name; - Mark(ident); + if (!call) { + return nullptr; + } - auto* resolved = sem_.ResolvedSymbol(ident); - return Switch( - resolved, // - [&](sem::Type* type) { return type_ctor_or_conv(type); }, - [&](sem::Function* func) { - return FunctionCall(expr, func, std::move(args), arg_behaviors); - }, - [&](sem::Variable* var) { - auto name = builder_->Symbols().NameFor(var->Declaration()->symbol); - AddError("cannot call variable '" + name + "'", ident->source); - AddNote("'" + name + "' declared here", var->Declaration()->source); - return nullptr; - }, - [&](Default) -> sem::Call* { - auto name = builder_->Symbols().NameFor(ident->symbol); - auto builtin_type = sem::ParseBuiltinType(name); - if (builtin_type != sem::BuiltinType::kNone) { - return BuiltinCall(expr, builtin_type, std::move(args), std::move(arg_tys)); - } - - TINT_ICE(Resolver, diagnostics_) - << expr->source << " unresolved CallExpression target:\n" - << "resolved: " << (resolved ? resolved->TypeInfo().name : "") << "\n" - << "name: " << builder_->Symbols().NameFor(ident->symbol); - return nullptr; - }); + return validator_.Call(call, current_statement_) ? call : nullptr; } sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, @@ -1414,133 +1445,6 @@ sem::Call* Resolver::FunctionCall(const ast::CallExpression* expr, return call; } -sem::Call* Resolver::TypeConversion(const ast::CallExpression* expr, - const sem::Type* target, - const sem::Expression* arg, - const sem::Type* source) { - // It is not valid to have a type-cast call expression inside a call - // statement. - if (IsCallStatement(expr)) { - AddError("type cast evaluated but not used", expr->source); - return nullptr; - } - - auto* call_target = utils::GetOrCreate( - type_conversions_, TypeConversionSig{target, source}, [&]() -> sem::TypeConversion* { - // Now that the argument types have been determined, make sure that - // they obey the conversion rules laid out in - // https://gpuweb.github.io/gpuweb/wgsl/#conversion-expr. - bool ok = Switch( - target, - [&](const sem::Vector* vec_type) { - return validator_.VectorConstructorOrCast(expr, vec_type); - }, - [&](const sem::Matrix* mat_type) { - // Note: Matrix types currently cannot be converted (the element - // type must only be f32). We implement this for the day we - // support other matrix element types. - return validator_.MatrixConstructorOrCast(expr, mat_type); - }, - [&](const sem::Array* arr_type) { - return validator_.ArrayConstructorOrCast(expr, arr_type); - }, - [&](const sem::Struct* struct_type) { - return validator_.StructureConstructorOrCast(expr, struct_type); - }, - [&](Default) { - if (target->is_scalar()) { - return validator_.ScalarConstructorOrCast(expr, target); - } - AddError("type is not constructible", expr->source); - return false; - }); - if (!ok) { - return nullptr; - } - - auto* param = - builder_->create(nullptr, // declaration - 0, // index - source->UnwrapRef(), // type - ast::StorageClass::kNone, // storage_class - ast::Access::kUndefined); // access - return builder_->create(target, param); - }); - - if (!call_target) { - return nullptr; - } - - auto val = EvaluateConstantValue(expr, target); - bool has_side_effects = arg->HasSideEffects(); - return builder_->create(expr, call_target, std::vector{arg}, - current_statement_, val, has_side_effects); -} - -sem::Call* Resolver::TypeConstructor(const ast::CallExpression* expr, - const sem::Type* ty, - const std::vector args, - const std::vector arg_tys) { - // It is not valid to have a type-constructor call expression as a call - // statement. - if (IsCallStatement(expr)) { - AddError("type constructor evaluated but not used", expr->source); - return nullptr; - } - - auto* call_target = utils::GetOrCreate( - type_ctors_, TypeConstructorSig{ty, arg_tys}, [&]() -> sem::TypeConstructor* { - // Now that the argument types have been determined, make sure that - // they obey the constructor type rules laid out in - // https://gpuweb.github.io/gpuweb/wgsl/#type-constructor-expr. - bool ok = Switch( - ty, - [&](const sem::Vector* vec_type) { - return validator_.VectorConstructorOrCast(expr, vec_type); - }, - [&](const sem::Matrix* mat_type) { - return validator_.MatrixConstructorOrCast(expr, mat_type); - }, - [&](const sem::Array* arr_type) { - return validator_.ArrayConstructorOrCast(expr, arr_type); - }, - [&](const sem::Struct* struct_type) { - return validator_.StructureConstructorOrCast(expr, struct_type); - }, - [&](Default) { - if (ty->is_scalar()) { - return validator_.ScalarConstructorOrCast(expr, ty); - } - AddError("type is not constructible", expr->source); - return false; - }); - if (!ok) { - return nullptr; - } - - return builder_->create( - ty, utils::Transform(arg_tys, - [&](const sem::Type* t, size_t i) -> const sem::Parameter* { - return builder_->create( - nullptr, // declaration - static_cast(i), // index - t->UnwrapRef(), // type - ast::StorageClass::kNone, // storage_class - ast::Access::kUndefined); // access - })); - }); - - if (!call_target) { - return nullptr; - } - - auto val = EvaluateConstantValue(expr, ty); - bool has_side_effects = - std::any_of(args.begin(), args.end(), [](auto* e) { return e->HasSideEffects(); }); - return builder_->create(expr, call_target, std::move(args), current_statement_, val, - has_side_effects); -} - sem::Expression* Resolver::Literal(const ast::LiteralExpression* literal) { auto* ty = Switch( literal, @@ -2464,22 +2368,6 @@ bool Resolver::IsBuiltin(Symbol symbol) const { return sem::ParseBuiltinType(name) != sem::BuiltinType::kNone; } -bool Resolver::IsCallStatement(const ast::Expression* expr) const { - return current_statement_ && - Is(current_statement_->Declaration(), - [&](auto* stmt) { return stmt->expr == expr; }); -} - -//////////////////////////////////////////////////////////////////////////////// -// Resolver::TypeConversionSig -//////////////////////////////////////////////////////////////////////////////// -bool Resolver::TypeConversionSig::operator==(const TypeConversionSig& rhs) const { - return target == rhs.target && source == rhs.source; -} -std::size_t Resolver::TypeConversionSig::Hasher::operator()(const TypeConversionSig& sig) const { - return utils::Hash(sig.target, sig.source); -} - //////////////////////////////////////////////////////////////////////////////// // Resolver::TypeConstructorSig //////////////////////////////////////////////////////////////////////////////// diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h index 4b75dc08ee..348c8e753a 100644 --- a/src/tint/resolver/resolver.h +++ b/src/tint/resolver/resolver.h @@ -193,14 +193,6 @@ class Resolver { const std::vector arg_tys); sem::Expression* Literal(const ast::LiteralExpression*); sem::Expression* MemberAccessor(const ast::MemberAccessorExpression*); - sem::Call* TypeConversion(const ast::CallExpression* expr, - const sem::Type* ty, - const sem::Expression* arg, - const sem::Type* arg_ty); - sem::Call* TypeConstructor(const ast::CallExpression* expr, - const sem::Type* ty, - const std::vector args, - const std::vector arg_tys); sem::Expression* UnaryOp(const ast::UnaryOpExpression*); // Statement resolving methods @@ -226,7 +218,6 @@ class Resolver { sem::Statement* VariableDeclStatement(const ast::VariableDeclStatement*); bool Statements(const ast::StatementList&); - /// Resolves the WorkgroupSize for the given function, assigning it to /// current_function_ bool WorkgroupSize(const ast::Function*); @@ -337,23 +328,6 @@ class Resolver { /// @returns true if the symbol is the name of a builtin function. bool IsBuiltin(Symbol) const; - /// @returns true if `expr` is the current CallStatement's CallExpression - bool IsCallStatement(const ast::Expression* expr) const; - - struct TypeConversionSig { - const sem::Type* target; - const sem::Type* source; - - bool operator==(const TypeConversionSig&) const; - - /// Hasher provides a hash function for the TypeConversionSig - struct Hasher { - /// @param sig the TypeConversionSig to create a hash for - /// @return the hash value - std::size_t operator()(const TypeConversionSig& sig) const; - }; - }; - struct TypeConstructorSig { const sem::Type* type; const std::vector parameters; @@ -381,8 +355,6 @@ class Resolver { std::unordered_map atomic_composite_info_; std::unordered_set marked_; std::unordered_map constant_ids_; - std::unordered_map - type_conversions_; std::unordered_map type_ctors_; diff --git a/src/tint/resolver/type_constructor_validation_test.cc b/src/tint/resolver/type_constructor_validation_test.cc index 4c37ee5ed5..5cd5b9fb29 100644 --- a/src/tint/resolver/type_constructor_validation_test.cc +++ b/src/tint/resolver/type_constructor_validation_test.cc @@ -57,7 +57,7 @@ constexpr Params ParamsFor() { } TEST_F(ResolverTypeConstructorValidationTest, InferTypeTest_Simple) { - // var a = 1; + // var a = 1i; // var b = a; auto* a = Var("a", nullptr, ast::StorageClass::kNone, Expr(1_i)); auto* b = Var("b", nullptr, ast::StorageClass::kNone, Expr("a")); @@ -147,15 +147,16 @@ TEST_P(InferTypeTest_FromArithmeticExpression, All) { << "expected: " << FriendlyName(expected) << "\n"; } static constexpr Params from_arithmetic_expression_cases[] = { - ParamsFor(), ParamsFor(), ParamsFor(), - ParamsFor>(), ParamsFor>(), - - // TODO(amaiorano): Uncomment once https://crbug.com/tint/680 is fixed - // ParamsFor>(), - // ParamsFor>(), - // ParamsFor>(), - // ParamsFor>>(), - // ParamsFor>>(), + ParamsFor(), + ParamsFor(), + ParamsFor(), + ParamsFor>(), + ParamsFor>(), + ParamsFor>(), + ParamsFor>(), + ParamsFor>(), + ParamsFor>>(), + ParamsFor>>(), }; INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, InferTypeTest_FromArithmeticExpression, @@ -408,7 +409,7 @@ TEST_F(ResolverTypeConstructorValidationTest, ConversionConstructorInvalid_TooMa WrapInFunction(a); ASSERT_FALSE(r()->Resolve()); - ASSERT_EQ(r()->error(), "12:34 error: expected zero or one value in constructor, got 2"); + EXPECT_THAT(r()->error(), HasSubstr("12:34 error: no matching constructor for f32(f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, ConversionConstructorInvalid_InvalidInitializer) { @@ -417,9 +418,8 @@ TEST_F(ResolverTypeConstructorValidationTest, ConversionConstructorInvalid_Inval WrapInFunction(a); ASSERT_FALSE(r()->Resolve()); - ASSERT_EQ(r()->error(), - "12:34 error: cannot construct 'f32' with a value of type " - "'array'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for f32(array)")); } } // namespace ConversionConstructTest @@ -727,101 +727,90 @@ namespace VectorConstructor { TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2F32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec2(Expr(Source{{12, 34}}, 1_i), 1_f); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), 1_i, 2_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'f32', found 'i32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(i32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2U32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec2(1_u, Expr(Source{{12, 34}}, 1_i)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), 1_u, 2_i)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'u32', found 'i32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(u32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2I32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec2(Expr(Source{{12, 34}}, 1_u), 1_i); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), 1_u, 2_i)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'i32', found 'u32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(u32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2Bool_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec2(true, Expr(Source{{12, 34}}, 1_i)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), true, 1_i)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'bool', found 'i32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(bool, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Error_Vec3ArgumentCardinalityTooLarge) { - auto* tc = vec2(Construct(Source{{12, 34}}, ty.vec3())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), vec3())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec2' with 3 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(vec3)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Error_Vec4ArgumentCardinalityTooLarge) { - auto* tc = vec2(Construct(Source{{12, 34}}, ty.vec4())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), vec4())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec2' with 4 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(vec4)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Error_TooManyArgumentsScalar) { - auto* tc = vec2(Expr(Source{{12, 34}}, 1_f), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), 1_f, 2_f, 3_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec2' with 3 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(f32, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Error_TooManyArgumentsVector) { - auto* tc = vec2(Construct(Source{{12, 34}}, ty.vec2()), - Construct(Source{{12, 40}}, ty.vec2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), vec2(), vec2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec2' with 4 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(vec2, vec2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Error_TooManyArgumentsVectorAndScalar) { - auto* tc = vec2(Construct(Source{{12, 34}}, ty.vec2()), Expr(Source{{12, 40}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), vec2(), 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec2' with 3 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(vec2, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Error_InvalidArgumentType) { - auto* tc = vec2(Construct(Source{{12, 34}}, ty.mat2x2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec2(), mat2x2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: expected vector or scalar type in vector " - "constructor; found: mat2x2"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(mat2x2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Success_ZeroValue) { @@ -969,117 +958,107 @@ TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec2_Success_Vec2 TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3F32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec3(1_f, 1_f, Expr(Source{{12, 34}}, 1_i)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), 1_f, 2_f, 3_i)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'f32', found 'i32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(f32, f32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3U32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec3(1_u, Expr(Source{{12, 34}}, 1_i), 1_u); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), 1_u, 2_i, 3_u)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'u32', found 'i32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(u32, i32, u32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3I32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec3(1_i, Expr(Source{{12, 34}}, 1_u), 1_i); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), 1_i, 2_u, 3_i)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'i32', found 'u32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(i32, u32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3Bool_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec3(true, Expr(Source{{12, 34}}, 1_i), false); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), false, 1_i, true)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'bool', found 'i32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(bool, i32, bool)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_Vec4ArgumentCardinalityTooLarge) { - auto* tc = vec3(Construct(Source{{12, 34}}, ty.vec4())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), vec4())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 4 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(vec4)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_TooFewArgumentsScalar) { - auto* tc = vec3(Expr(Source{{12, 34}}, 1_f), Expr(Source{{12, 40}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), 1_f, 2_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 2 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_TooManyArgumentsScalar) { - auto* tc = vec3(Expr(Source{{12, 34}}, 1_f), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f), Expr(Source{{12, 52}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), 1_f, 2_f, 3_f, 4_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 4 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(f32, f32, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_TooFewArgumentsVec2) { - auto* tc = vec3(Construct(Source{{12, 34}}, ty.vec2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), vec2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 2 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(vec2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_TooManyArgumentsVec2) { - auto* tc = vec3(Construct(Source{{12, 34}}, ty.vec2()), - Construct(Source{{12, 40}}, ty.vec2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), vec2(), vec2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 4 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(vec2, vec2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_TooManyArgumentsVec2AndScalar) { - auto* tc = vec3(Construct(Source{{12, 34}}, ty.vec2()), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), vec2(), 1_f, 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 4 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(vec2, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_TooManyArgumentsVec3) { - auto* tc = vec3(Construct(Source{{12, 34}}, ty.vec3()), Expr(Source{{12, 40}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), vec3(), 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 4 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(vec3, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Error_InvalidArgumentType) { - auto* tc = vec3(Construct(Source{{12, 34}}, ty.mat2x2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), mat2x2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: expected vector or scalar type in vector " - "constructor; found: mat2x2"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(mat2x2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Success_ZeroValue) { @@ -1273,163 +1252,156 @@ TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec3_Success_Vec3 TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4F32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec4(1_f, 1_f, Expr(Source{{12, 34}}, 1_i), 1_f); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), 1_f, 1_f, 1_i, 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'f32', found 'i32'"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(f32, f32, i32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4U32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec4(1_u, 1_u, Expr(Source{{12, 34}}, 1_i), 1_u); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), 1_u, 1_u, 1_i, 1_u)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'u32', found 'i32'"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(u32, u32, i32, u32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4I32_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec4(1_i, 1_i, Expr(Source{{12, 34}}, 1_u), 1_i); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), 1_i, 1_i, 1_u, 1_i)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'i32', found 'u32'"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(i32, i32, u32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4Bool_Error_ScalarArgumentTypeMismatch) { - auto* tc = vec4(true, false, Expr(Source{{12, 34}}, 1_i), true); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), true, false, 1_i, true)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'bool', found 'i32'"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(bool, bool, i32, bool)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooFewArgumentsScalar) { - auto* tc = vec4(Expr(Source{{12, 34}}, 1_f), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), 1_f, 2_f, 3_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 3 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(f32, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsScalar) { - auto* tc = vec4(Expr(Source{{12, 34}}, 1_f), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f), Expr(Source{{12, 52}}, 1_f), - Expr(Source{{12, 58}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), 1_f, 2_f, 3_f, 4_f, 5_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 5 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(f32, f32, f32, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooFewArgumentsVec2AndScalar) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec2()), Expr(Source{{12, 40}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec2(), 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 3 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec2, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec2AndScalars) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec2()), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f), Expr(Source{{12, 52}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec2(), 1_f, 2_f, 3_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 5 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec2, f32, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec2Vec2Scalar) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec2()), - Construct(Source{{12, 40}}, ty.vec2()), Expr(Source{{12, 46}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec2(), vec2(), 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 5 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec2, vec2, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec2Vec2Vec2) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec2()), - Construct(Source{{12, 40}}, ty.vec2()), - Construct(Source{{12, 40}}, ty.vec2())); - WrapInFunction(tc); + WrapInFunction( + Construct(Source{{12, 34}}, ty.vec4(), vec2(), vec2(), vec2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 6 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr( + "12:34 error: no matching constructor for vec4(vec2, vec2, vec2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooFewArgumentsVec3) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec3())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec3())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 3 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec3)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec3AndScalars) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec3()), Expr(Source{{12, 40}}, 1_f), - Expr(Source{{12, 46}}, 1_f)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec3(), 1_f, 2_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 5 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec3, f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec3AndVec2) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec3()), - Construct(Source{{12, 40}}, ty.vec2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec3(), vec2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 5 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec3, vec2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec2AndVec3) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec2()), - Construct(Source{{12, 40}}, ty.vec3())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec2(), vec3())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 5 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec2, vec3)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_TooManyArgumentsVec3AndVec3) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.vec3()), - Construct(Source{{12, 40}}, ty.vec3())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), vec3(), vec3())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec4' with 6 component(s)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(vec3, vec3)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Error_InvalidArgumentType) { - auto* tc = vec4(Construct(Source{{12, 34}}, ty.mat2x2())); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec4(), mat2x2())); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: expected vector or scalar type in vector " - "constructor; found: mat2x2"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec4(mat2x2)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Success_ZeroValue) { @@ -1590,13 +1562,13 @@ TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vec4_Success_Vec4 TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_NestedVectorConstructors_InnerError) { - auto* tc = vec4( - vec4(1_f, 1_f, vec3(Expr(Source{{12, 34}}, 1_f), Expr(Source{{12, 34}}, 1_f))), - 1_f); - WrapInFunction(tc); + WrapInFunction(vec4(vec4(1_f, 1_f, // + Construct(Source{{12, 34}}, ty.vec3(), 1_f, 1_f)), + 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: attempted to construct 'vec3' with 2 component(s)"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(f32, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_NestedVectorConstructors_Success) { @@ -1615,13 +1587,11 @@ TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vector_Alias_Argu auto* alias = Alias("UnsignedInt", ty.u32()); Global("uint_var", ty.Of(alias), ast::StorageClass::kPrivate); - auto* tc = vec2(Expr(Source{{12, 34}}, "uint_var")); + auto* tc = Construct(Source{{12, 34}}, ty.vec2(), "uint_var"); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'f32', found 'u32'"); + EXPECT_THAT(r()->error(), HasSubstr("12:34 error: no matching constructor for vec2(u32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vector_Alias_Argument_Success) { @@ -1640,13 +1610,11 @@ TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vector_ElementTyp // vec2(1.0f, 1u) auto* vec_type = ty.vec(ty.Of(f32_alias), 2); - auto* tc = Construct(Source{{12, 34}}, vec_type, 1_f, Expr(Source{{12, 40}}, 1_u)); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, vec_type, 1_f, 1_u)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:40 error: type in vector constructor does not match vector " - "type: expected 'f32', found 'u32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec2(f32, u32)")); } TEST_F(ResolverTypeConstructorValidationTest, Expr_Constructor_Vector_ElementTypeAlias_Success) { @@ -1666,13 +1634,11 @@ TEST_F(ResolverTypeConstructorValidationTest, // vec3(vec(), 1.0f) auto* vec_type = ty.vec(ty.Of(f32_alias), 2); - auto* tc = vec3(Construct(Source{{12, 34}}, vec_type), 1_f); - WrapInFunction(tc); + WrapInFunction(Construct(Source{{12, 34}}, ty.vec3(), Construct(vec_type), 1_f)); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - "12:34 error: type in vector constructor does not match vector " - "type: expected 'u32', found 'f32'"); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for vec3(vec2, f32)")); } TEST_F(ResolverTypeConstructorValidationTest, @@ -1946,10 +1912,10 @@ TEST_F(ResolverTypeConstructorValidationTest, InferVec4ElementTypeFromVec2AndVec } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVectorElementTypeWithoutArgs) { - WrapInFunction(Construct(create(Source{{12, 34}}, nullptr, 3))); + WrapInFunction(Construct(Source{{12, 34}}, create(nullptr, 3))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: missing vector element type"); + EXPECT_THAT(r()->error(), HasSubstr("12:34 error: no matching constructor for vec3()")); } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec2ElementTypeFromScalarsMismatch) { @@ -1958,11 +1924,7 @@ TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec2ElementTypeFromScal Expr(Source{{1, 3}}, 2_u))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ( - r()->error(), - R"(1:1 error: cannot infer vector element type, as constructor arguments have different types -1:2 note: argument 0 has type i32 -1:3 note: argument 1 has type u32)"); + EXPECT_THAT(r()->error(), HasSubstr("1:1 error: no matching constructor for vec2(i32, u32)")); } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec3ElementTypeFromScalarsMismatch) { @@ -1972,12 +1934,8 @@ TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec3ElementTypeFromScal Expr(Source{{1, 4}}, 3_i))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ( - r()->error(), - R"(1:1 error: cannot infer vector element type, as constructor arguments have different types -1:2 note: argument 0 has type i32 -1:3 note: argument 1 has type u32 -1:4 note: argument 2 has type i32)"); + EXPECT_THAT(r()->error(), + HasSubstr("1:1 error: no matching constructor for vec3(i32, u32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec3ElementTypeFromScalarAndVec2Mismatch) { @@ -1986,11 +1944,8 @@ TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec3ElementTypeFromScal Construct(Source{{1, 3}}, ty.vec2(), 2_f, 3_f))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ( - r()->error(), - R"(1:1 error: cannot infer vector element type, as constructor arguments have different types -1:2 note: argument 0 has type i32 -1:3 note: argument 1 has type vec2)"); + EXPECT_THAT(r()->error(), + HasSubstr("1:1 error: no matching constructor for vec3(i32, vec2)")); } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromScalarsMismatch) { @@ -2001,13 +1956,8 @@ TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromScal Expr(Source{{1, 5}}, 4_i))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ( - r()->error(), - R"(1:1 error: cannot infer vector element type, as constructor arguments have different types -1:2 note: argument 0 has type i32 -1:3 note: argument 1 has type i32 -1:4 note: argument 2 has type f32 -1:5 note: argument 3 has type i32)"); + EXPECT_THAT(r()->error(), + HasSubstr("1:1 error: no matching constructor for vec4(i32, i32, f32, i32)")); } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromScalarAndVec3Mismatch) { @@ -2016,11 +1966,8 @@ TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromScal Construct(Source{{1, 3}}, ty.vec3(), 2_u, 3_u, 4_u))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ( - r()->error(), - R"(1:1 error: cannot infer vector element type, as constructor arguments have different types -1:2 note: argument 0 has type i32 -1:3 note: argument 1 has type vec3)"); + EXPECT_THAT(r()->error(), + HasSubstr("1:1 error: no matching constructor for vec4(i32, vec3)")); } TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromVec2AndVec2Mismatch) { @@ -2029,11 +1976,8 @@ TEST_F(ResolverTypeConstructorValidationTest, CannotInferVec4ElementTypeFromVec2 Construct(Source{{1, 3}}, ty.vec2(), 3_u, 4_u))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ( - r()->error(), - R"(1:1 error: cannot infer vector element type, as constructor arguments have different types -1:2 note: argument 0 has type vec2 -1:3 note: argument 1 has type vec2)"); + EXPECT_THAT(r()->error(), + HasSubstr("1:1 error: no matching constructor for vec4(vec2, vec2)")); } } // namespace VectorConstructor @@ -2058,22 +2002,23 @@ TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooFewArguments) { std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns - 1; i++) { + for (uint32_t i = 0; i < param.columns - 1; i++) { auto* vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); - if (i > 1) { + args.push_back(Construct(vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ElementConstructor_Error_TooFewArguments) { @@ -2083,21 +2028,22 @@ TEST_P(MatrixConstructorTest, Expr_ElementConstructor_Error_TooFewArguments) { std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns * param.rows - 1; i++) { - args.push_back(Construct(Source{{12, i}}, ty.f32())); - if (i > 1) { + for (uint32_t i = 0; i < param.columns * param.rows - 1; i++) { + args.push_back(Construct(ty.f32())); + if (i > 0) { args_tys << ", "; } args_tys << "f32"; } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooManyArguments) { @@ -2107,22 +2053,23 @@ TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooManyArguments) { std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns + 1; i++) { + for (uint32_t i = 0; i < param.columns + 1; i++) { auto* vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); - if (i > 1) { + args.push_back(Construct(vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ElementConstructor_Error_TooManyArguments) { @@ -2132,21 +2079,22 @@ TEST_P(MatrixConstructorTest, Expr_ElementConstructor_Error_TooManyArguments) { std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns * param.rows + 1; i++) { - args.push_back(Construct(Source{{12, i}}, ty.f32())); - if (i > 1) { + for (uint32_t i = 0; i < param.columns * param.rows + 1; i++) { + args.push_back(Construct(ty.f32())); + if (i > 0) { args_tys << ", "; } args_tys << "f32"; } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_InvalidArgumentType) { @@ -2156,22 +2104,23 @@ TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_InvalidArgumentType) std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); - if (i > 1) { + args.push_back(Construct(vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ElementConstructor_Error_InvalidArgumentType) { @@ -2181,21 +2130,22 @@ TEST_P(MatrixConstructorTest, Expr_ElementConstructor_Error_InvalidArgumentType) std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { - args.push_back(Expr(Source{{12, i}}, 1_u)); - if (i > 1) { + for (uint32_t i = 0; i < param.columns; i++) { + args.push_back(Expr(1_u)); + if (i > 0) { args_tys << ", "; } args_tys << "u32"; } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooFewRowsInVectorArgument) { @@ -2210,10 +2160,10 @@ TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooFewRowsInVectorArg std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns - 1; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* valid_vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, valid_vec_type)); - if (i > 1) { + args.push_back(Construct(valid_vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; @@ -2224,12 +2174,13 @@ TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooFewRowsInVectorArg args_tys << ", vec" << (param.rows - 1) << ""; auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooManyRowsInVectorArgument) { @@ -2244,26 +2195,26 @@ TEST_P(MatrixConstructorTest, Expr_ColumnConstructor_Error_TooManyRowsInVectorAr std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns - 1; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* valid_vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, valid_vec_type)); - if (i > 1) { + args.push_back(Construct(valid_vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; } - const size_t kInvalidLoc = 2 * (param.columns - 1); auto* invalid_vec_type = ty.vec(param.rows + 1); - args.push_back(Construct(Source{{12, kInvalidLoc}}, invalid_vec_type)); + args.push_back(Construct(invalid_vec_type)); args_tys << ", vec" << (param.rows + 1) << ""; auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_Constructor_ZeroValue_Success) { @@ -2283,13 +2234,13 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_WithColumns_Success) { const auto param = GetParam(); ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); + args.push_back(Construct(vec_type)); } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(matrix_type, std::move(args)); WrapInFunction(tc); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -2301,12 +2252,12 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_WithElements_Success) { const auto param = GetParam(); ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns * param.rows; i++) { - args.push_back(Construct(Source{{12, i}}, ty.f32())); + for (uint32_t i = 0; i < param.columns * param.rows; i++) { + args.push_back(Construct(ty.f32())); } auto* matrix_type = ty.mat(param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(matrix_type, std::move(args)); WrapInFunction(tc); ASSERT_TRUE(r()->Resolve()) << r()->error(); @@ -2320,22 +2271,23 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_ElementTypeAlias_Error) { std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* vec_type = ty.vec(ty.u32(), param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); - if (i > 1) { + args.push_back(Construct(vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; } auto* matrix_type = ty.mat(ty.Of(f32_alias), param.columns, param.rows); - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_Constructor_ElementTypeAlias_Success) { @@ -2345,9 +2297,9 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_ElementTypeAlias_Success) { auto* f32_alias = Alias("Float32", ty.f32()); ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* vec_type = ty.vec(param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); + args.push_back(Construct(vec_type)); } auto* matrix_type = ty.mat(ty.Of(f32_alias), param.columns, param.rows); @@ -2359,18 +2311,13 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_ElementTypeAlias_Success) { TEST_F(ResolverTypeConstructorValidationTest, Expr_MatrixConstructor_ArgumentTypeAlias_Error) { auto* alias = Alias("VectorUnsigned2", ty.vec2()); - auto* tc = mat2x2(Construct(Source{{12, 34}}, ty.Of(alias)), vec2()); + auto* tc = Construct(Source{{12, 34}}, ty.mat2x2(), Construct(ty.Of(alias)), vec2()); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), - R"(12:34 error: no matching constructor mat2x2(vec2, vec2) - -3 candidates available: - mat2x2() - mat2x2(f32,...,f32) // 4 arguments - mat2x2(vec2, vec2) -)"); + EXPECT_THAT( + r()->error(), + HasSubstr("12:34 error: no matching constructor for mat2x2(vec2, vec2)")); } TEST_P(MatrixConstructorTest, Expr_Constructor_ArgumentTypeAlias_Success) { @@ -2380,8 +2327,8 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_ArgumentTypeAlias_Success) { auto* vec_alias = Alias("VectorFloat2", vec_type); ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { - args.push_back(Construct(Source{{12, i}}, ty.Of(vec_alias))); + for (uint32_t i = 0; i < param.columns; i++) { + args.push_back(Construct(ty.Of(vec_alias))); } auto* tc = Construct(Source{}, matrix_type, std::move(args)); @@ -2397,21 +2344,22 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_ArgumentElementTypeAlias_Error) { std::stringstream args_tys; ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* vec_type = ty.vec(ty.Of(f32_alias), param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); - if (i > 1) { + args.push_back(Construct(vec_type)); + if (i > 0) { args_tys << ", "; } args_tys << "vec" << param.rows << ""; } - auto* tc = Construct(Source{}, matrix_type, std::move(args)); + auto* tc = Construct(Source{{12, 34}}, matrix_type, std::move(args)); WrapInFunction(tc); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), HasSubstr("12:1 error: no matching constructor " + MatrixStr(param) + - "(" + args_tys.str() + ")\n\n3 candidates available:")); + EXPECT_THAT(r()->error(), + HasSubstr("12:34 error: no matching constructor for " + MatrixStr(param) + "(" + + args_tys.str() + ")\n\n3 candidate constructors:")); } TEST_P(MatrixConstructorTest, Expr_Constructor_ArgumentElementTypeAlias_Success) { @@ -2419,9 +2367,9 @@ TEST_P(MatrixConstructorTest, Expr_Constructor_ArgumentElementTypeAlias_Success) auto* f32_alias = Alias("Float32", ty.f32()); ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { auto* vec_type = ty.vec(ty.Of(f32_alias), param.rows); - args.push_back(Construct(Source{{12, i}}, vec_type)); + args.push_back(Construct(vec_type)); } auto* matrix_type = ty.mat(param.columns, param.rows); @@ -2435,7 +2383,7 @@ TEST_P(MatrixConstructorTest, InferElementTypeFromVectors) { const auto param = GetParam(); ast::ExpressionList args; - for (uint32_t i = 1; i <= param.columns; i++) { + for (uint32_t i = 0; i < param.columns; i++) { args.push_back(Construct(ty.vec(param.rows))); } @@ -2464,20 +2412,21 @@ TEST_P(MatrixConstructorTest, CannotInferElementTypeFromVectors_Mismatch) { const auto param = GetParam(); std::stringstream err; - err << "12:34 error: cannot infer matrix element type, as constructor " - "arguments have different types"; + err << "12:34 error: no matching constructor for mat" << param.columns << "x" << param.rows + << "("; ast::ExpressionList args; for (uint32_t i = 0; i < param.columns; i++) { - err << "\n"; - auto src = Source{{1, 10 + i}}; + if (i > 0) { + err << ", "; + } if (i == 1) { // Odd one out - args.push_back(Construct(src, ty.vec(param.rows))); - err << src << " note: argument " << i << " has type vec" << param.rows << ""; + args.push_back(Construct(ty.vec(param.rows))); + err << "vec" << param.rows << ""; } else { - args.push_back(Construct(src, ty.vec(param.rows))); - err << src << " note: argument " << i << " has type vec" << param.rows << ""; + args.push_back(Construct(ty.vec(param.rows))); + err << "vec" << param.rows << ""; } } @@ -2485,33 +2434,37 @@ TEST_P(MatrixConstructorTest, CannotInferElementTypeFromVectors_Mismatch) { WrapInFunction(Construct(Source{{12, 34}}, matrix_type, std::move(args))); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), err.str()); + EXPECT_THAT(r()->error(), HasSubstr(err.str())); } TEST_P(MatrixConstructorTest, CannotInferElementTypeFromScalars_Mismatch) { const auto param = GetParam(); std::stringstream err; - err << "12:34 error: cannot infer matrix element type, as constructor " - "arguments have different types"; + err << "12:34 error: no matching constructor for mat" << param.columns << "x" << param.rows + << "("; + ast::ExpressionList args; for (uint32_t i = 0; i < param.rows * param.columns; i++) { - err << "\n"; - auto src = Source{{1, 10 + i}}; + if (i > 0) { + err << ", "; + } if (i == 3) { - args.push_back(Expr(src, static_cast(i))); // The odd one out - err << src << " note: argument " << i << " has type i32"; + args.push_back(Expr(static_cast(i))); // The odd one out + err << "i32"; } else { - args.push_back(Expr(src, static_cast(i))); - err << src << " note: argument " << i << " has type f32"; + args.push_back(Expr(static_cast(i))); + err << "f32"; } } + err << ")"; + auto* matrix_type = create(nullptr, param.rows, param.columns); WrapInFunction(Construct(Source{{12, 34}}, matrix_type, std::move(args))); EXPECT_FALSE(r()->Resolve()); - EXPECT_THAT(r()->error(), err.str()); + EXPECT_THAT(r()->error(), HasSubstr(err.str())); } INSTANTIATE_TEST_SUITE_P(ResolverTypeConstructorValidationTest, @@ -2729,7 +2682,7 @@ TEST_F(ResolverTypeConstructorValidationTest, TypeConversionAsStatement) { WrapInFunction(CallStmt(Construct(Source{{12, 34}}, ty.f32(), 1_i))); EXPECT_FALSE(r()->Resolve()); - EXPECT_EQ(r()->error(), "12:34 error: type cast evaluated but not used"); + EXPECT_EQ(r()->error(), "12:34 error: type conversion evaluated but not used"); } } // namespace diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc index df9c7c08e0..73e1acfd3a 100644 --- a/src/tint/resolver/validator.cc +++ b/src/tint/resolver/validator.cc @@ -1356,6 +1356,35 @@ bool Validator::ContinueStatement(const sem::Statement* stmt, return true; } +bool Validator::Call(const sem::Call* call, sem::Statement* current_statement) const { + auto* expr = call->Declaration(); + bool is_call_stmt = + current_statement && Is(current_statement->Declaration(), + [&](auto* stmt) { return stmt->expr == expr; }); + + return Switch( + call->Target(), // + [&](const sem::TypeConversion*) { + if (is_call_stmt) { + AddError("type conversion evaluated but not used", call->Declaration()->source); + return false; + } + return true; + }, + [&](const sem::TypeConstructor* ctor) { + if (is_call_stmt) { + AddError("type constructor evaluated but not used", call->Declaration()->source); + return false; + } + return Switch( + ctor->ReturnType(), // + [&](const sem::Array* arr) { return ArrayConstructor(expr, arr); }, + [&](const sem::Struct* str) { return StructureConstructor(expr, str); }, + [&](Default) { return true; }); + }, + [&](Default) { return true; }); +} + bool Validator::DiscardStatement(const sem::Statement* stmt, sem::Statement* current_statement) const { if (auto* continuing = ClosestContinuing(/*stop_at_loop*/ false, current_statement)) { @@ -1649,8 +1678,8 @@ bool Validator::FunctionCall(const sem::Call* call, sem::Statement* current_stat return true; } -bool Validator::StructureConstructorOrCast(const ast::CallExpression* ctor, - const sem::Struct* struct_type) const { +bool Validator::StructureConstructor(const ast::CallExpression* ctor, + const sem::Struct* struct_type) const { if (!struct_type->IsConstructible()) { AddError("struct constructor has non-constructible type", ctor->source); return false; @@ -1682,8 +1711,8 @@ bool Validator::StructureConstructorOrCast(const ast::CallExpression* ctor, return true; } -bool Validator::ArrayConstructorOrCast(const ast::CallExpression* ctor, - const sem::Array* array_type) const { +bool Validator::ArrayConstructor(const ast::CallExpression* ctor, + const sem::Array* array_type) const { auto& values = ctor->args; auto* elem_ty = array_type->ElemType(); for (auto* value : values) { @@ -1721,66 +1750,6 @@ bool Validator::ArrayConstructorOrCast(const ast::CallExpression* ctor, return true; } -bool Validator::VectorConstructorOrCast(const ast::CallExpression* ctor, - const sem::Vector* vec_type) const { - auto& values = ctor->args; - auto* elem_ty = vec_type->type(); - size_t value_cardinality_sum = 0; - for (auto* value : values) { - auto* value_ty = sem_.TypeOf(value)->UnwrapRef(); - if (value_ty->is_scalar()) { - if (elem_ty != value_ty) { - AddError( - "type in vector constructor does not match vector type: " - "expected '" + - sem_.TypeNameOf(elem_ty) + "', found '" + sem_.TypeNameOf(value_ty) + "'", - value->source); - return false; - } - - value_cardinality_sum++; - } else if (auto* value_vec = value_ty->As()) { - auto* value_elem_ty = value_vec->type(); - // A mismatch of vector type parameter T is only an error if multiple - // arguments are present. A single argument constructor constitutes a - // type conversion expression. - if (elem_ty != value_elem_ty && values.size() > 1u) { - AddError( - "type in vector constructor does not match vector type: " - "expected '" + - sem_.TypeNameOf(elem_ty) + "', found '" + sem_.TypeNameOf(value_elem_ty) + - "'", - value->source); - return false; - } - - value_cardinality_sum += value_vec->Width(); - } else { - // A vector constructor can only accept vectors and scalars. - AddError("expected vector or scalar type in vector constructor; found: " + - sem_.TypeNameOf(value_ty), - value->source); - return false; - } - } - - // A correct vector constructor must either be a zero-value expression, - // a single-value initializer (splat) expression, or the number of components - // of all constructor arguments must add up to the vector cardinality. - if (value_cardinality_sum > 1 && value_cardinality_sum != vec_type->Width()) { - if (values.empty()) { - TINT_ICE(Resolver, diagnostics_) << "constructor arguments expected to be non-empty!"; - } - const Source& values_start = values[0]->source; - const Source& values_end = values[values.size() - 1]->source; - AddError("attempted to construct '" + sem_.TypeNameOf(vec_type) + "' with " + - std::to_string(value_cardinality_sum) + " component(s)", - Source::Combine(values_start, values_end)); - return false; - } - return true; -} - bool Validator::Vector(const sem::Vector* ty, const Source& source) const { if (!ty->type()->is_scalar()) { AddError("vector element type must be 'bool', 'f32', 'i32' or 'u32'", source); @@ -1797,117 +1766,6 @@ bool Validator::Matrix(const sem::Matrix* ty, const Source& source) const { return true; } -bool Validator::MatrixConstructorOrCast(const ast::CallExpression* ctor, - const sem::Matrix* matrix_ty) const { - auto& values = ctor->args; - // Zero Value expression - if (values.empty()) { - return true; - } - - if (!Matrix(matrix_ty, ctor->source)) { - return false; - } - - std::vector arg_tys; - arg_tys.reserve(values.size()); - for (auto* value : values) { - arg_tys.emplace_back(sem_.TypeOf(value)->UnwrapRef()); - } - - auto* elem_type = matrix_ty->type(); - auto num_elements = matrix_ty->columns() * matrix_ty->rows(); - - // Print a generic error for an invalid matrix constructor, showing the - // available overloads. - auto print_error = [&]() { - const Source& values_start = values[0]->source; - const Source& values_end = values[values.size() - 1]->source; - auto type_name = sem_.TypeNameOf(matrix_ty); - auto elem_type_name = sem_.TypeNameOf(elem_type); - std::stringstream ss; - ss << "no matching constructor " + type_name << "("; - for (size_t i = 0; i < values.size(); i++) { - if (i > 0) { - ss << ", "; - } - ss << arg_tys[i]->FriendlyName(symbols_); - } - ss << ")" << std::endl << std::endl; - ss << "3 candidates available:" << std::endl; - ss << " " << type_name << "()" << std::endl; - ss << " " << type_name << "(" << elem_type_name << ",...," << elem_type_name << ")" - << " // " << std::to_string(num_elements) << " arguments" << std::endl; - ss << " " << type_name << "("; - for (uint32_t c = 0; c < matrix_ty->columns(); c++) { - if (c > 0) { - ss << ", "; - } - ss << VectorPretty(matrix_ty->rows(), elem_type); - } - ss << ")" << std::endl; - AddError(ss.str(), Source::Combine(values_start, values_end)); - }; - - const sem::Type* expected_arg_type = nullptr; - if (num_elements == values.size()) { - // Column-major construction from scalar elements. - expected_arg_type = matrix_ty->type(); - } else if (matrix_ty->columns() == values.size()) { - // Column-by-column construction from vectors. - expected_arg_type = matrix_ty->ColumnType(); - } else { - print_error(); - return false; - } - - for (auto* arg_ty : arg_tys) { - if (arg_ty != expected_arg_type) { - print_error(); - return false; - } - } - - return true; -} - -bool Validator::ScalarConstructorOrCast(const ast::CallExpression* ctor, - const sem::Type* ty) const { - if (ctor->args.size() == 0) { - return true; - } - if (ctor->args.size() > 1) { - AddError( - "expected zero or one value in constructor, got " + std::to_string(ctor->args.size()), - ctor->source); - return false; - } - - // Validate constructor - auto* value = ctor->args[0]; - auto* value_ty = sem_.TypeOf(value)->UnwrapRef(); - - using Bool = sem::Bool; - using I32 = sem::I32; - using U32 = sem::U32; - using F16 = sem::F16; - using F32 = sem::F32; - - const bool is_valid = - (ty->Is() && value_ty->is_scalar()) || (ty->Is() && value_ty->is_scalar()) || - (ty->Is() && value_ty->is_scalar()) || (ty->Is() && value_ty->is_scalar()) || - (ty->Is() && value_ty->is_scalar()); - if (!is_valid) { - AddError("cannot construct '" + sem_.TypeNameOf(ty) + "' with a value of type '" + - sem_.TypeNameOf(value_ty) + "'", - ctor->source); - - return false; - } - - return true; -} - bool Validator::PipelineStages(const std::vector& entry_points) const { auto check_workgroup_storage = [&](const sem::Function* func, const sem::Function* entry_point) { diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h index 21c8e70448..6efb543fce 100644 --- a/src/tint/resolver/validator.h +++ b/src/tint/resolver/validator.h @@ -183,6 +183,12 @@ class Validator { /// @returns true on success, false otherwise bool ContinueStatement(const sem::Statement* stmt, sem::Statement* current_statement) const; + /// Validates a call + /// @param call the call + /// @param current_statement the current statement being resolved + /// @returns true on success, false otherwise + bool Call(const sem::Call* call, sem::Statement* current_statement) const; + /// Validates a discard statement /// @param stmt the statement to validate /// @param current_statement the current statement being resolved @@ -308,12 +314,12 @@ class Validator { /// @returns true on success, false otherwise. bool Structure(const sem::Struct* str, ast::PipelineStage stage) const; - /// Validates a structure constructor or cast + /// Validates a structure constructor /// @param ctor the call expression to validate /// @param struct_type the type of the structure /// @returns true on success, false otherwise - bool StructureConstructorOrCast(const ast::CallExpression* ctor, - const sem::Struct* struct_type) const; + bool StructureConstructor(const ast::CallExpression* ctor, + const sem::Struct* struct_type) const; /// Validates a switch statement /// @param s the switch to validate @@ -342,31 +348,11 @@ class Validator { /// @returns true on success, false otherwise bool Vector(const sem::Vector* ty, const Source& source) const; - /// Validates a vector constructor or cast - /// @param ctor the call expression to validate - /// @param vec_type the vector type - /// @returns true on success, false otherwise - bool VectorConstructorOrCast(const ast::CallExpression* ctor, - const sem::Vector* vec_type) const; - - /// Validates a matrix constructor or cast - /// @param ctor the call expression to validate - /// @param matrix_type the type of the matrix - /// @returns true on success, false otherwise - bool MatrixConstructorOrCast(const ast::CallExpression* ctor, - const sem::Matrix* matrix_type) const; - - /// Validates a scalar constructor or cast - /// @param ctor the call expression to validate - /// @param type the type of the scalar - /// @returns true on success, false otherwise. - bool ScalarConstructorOrCast(const ast::CallExpression* ctor, const sem::Type* type) const; - - /// Validates an array constructor or cast + /// Validates an array constructor /// @param ctor the call expresion to validate /// @param arr_type the type of the array /// @returns true on success, false otherwise - bool ArrayConstructorOrCast(const ast::CallExpression* ctor, const sem::Array* arr_type) const; + bool ArrayConstructor(const ast::CallExpression* ctor, const sem::Array* arr_type) const; /// Validates a texture builtin function /// @param call the builtin call to validate diff --git a/src/tint/sem/parameter_usage.cc b/src/tint/sem/parameter_usage.cc index 4891bbaf0a..010272a0a4 100644 --- a/src/tint/sem/parameter_usage.cc +++ b/src/tint/sem/parameter_usage.cc @@ -56,6 +56,24 @@ const char* str(ParameterUsage usage) { return "texture"; case ParameterUsage::kValue: return "value"; + case ParameterUsage::kW: + return "w"; + case ParameterUsage::kX: + return "x"; + case ParameterUsage::kXy: + return "xy"; + case ParameterUsage::kXyz: + return "xyz"; + case ParameterUsage::kY: + return "y"; + case ParameterUsage::kYz: + return "yz"; + case ParameterUsage::kZ: + return "z"; + case ParameterUsage::kZw: + return "zw"; + case ParameterUsage::kZyw: + return "zyw"; } return ""; } diff --git a/src/tint/sem/parameter_usage.h b/src/tint/sem/parameter_usage.h index 85ef64fb53..b17ae3e502 100644 --- a/src/tint/sem/parameter_usage.h +++ b/src/tint/sem/parameter_usage.h @@ -44,6 +44,15 @@ enum class ParameterUsage { kSampler, kTexture, kValue, + kW, + kX, + kXy, + kXyz, + kY, + kYz, + kZ, + kZw, + kZyw, }; /// @returns a string representation of the given parameter usage.