Import Tint changes from Dawn
Changes:
- 605b7fbadcc85f67ea2253bcd903784d9f602534 tint/writer/glsl: Simplify map keys with UnorderedKeyWrap... by Ben Clayton <bclayton@google.com>
- ac660c27942e95577aae79885307d3777de58050 tint: Implement const eval of unary complement by Ben Clayton <bclayton@google.com>
- 83bd738ab4e49157599d51b998484a8e3a068d4b tint/resolver: Track evaluation stage by Ben Clayton <bclayton@google.com>
- db8959555036296070d2d5004950f32ee1b85c57 tint: Add a Count() method to BlockAllocator. by Ben Clayton <bclayton@google.com>
- 6a80ce6c66bf7dfc2e61d530c82b94105feca491 tint/resolver: Use the intrinsic table for type const dis... by Ben Clayton <bclayton@google.com>
- 8b0ceea0b1da712480388f93a1d012a16081890c tint: Clean up legacy type cruft by Ben Clayton <bclayton@google.com>
- f19cb029b84f67d4bedf357626d26d809af49a8c tint: Remove single scalar matrix constructors. by Ben Clayton <bclayton@google.com>
- 65c5c9d92b2d1b8d73bc7f1fca9a3d54a29ec93c tint/resolver: Add ConstEval class by Ben Clayton <bclayton@google.com>
- cfe07a1b333024fe79b4d341a0e5539e9d9d0203 tint/resolver: Shuffle validation code by Ben Clayton <bclayton@google.com>
- e0ecd86e73ff9e6def9e1460cb0291f175044046 tint/writer/glsl: Fix emitting float modulo with mixing t... by Zhaoming Jiang <zhaoming.jiang@intel.com>
- 32bdf41ed38155f91c199429233040c5a57a262a tint/resolver: Remove logic for module-scope let by Ben Clayton <bclayton@google.com>
GitOrigin-RevId: 605b7fbadcc85f67ea2253bcd903784d9f602534
Change-Id: I29c79a615b90e418e99b68e7a8b3809e7bb47518
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/96340
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index fb51327..c0c0b62 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -398,7 +398,6 @@
"resolver/intrinsic_table.inl",
"resolver/resolver.cc",
"resolver/resolver.h",
- "resolver/resolver_constants.cc",
"resolver/sem_helper.cc",
"resolver/sem_helper.h",
"resolver/uniformity.cc",
@@ -421,6 +420,7 @@
"sem/constant.h",
"sem/depth_multisampled_texture.h",
"sem/depth_texture.h",
+ "sem/evaluation_stage.h",
"sem/expression.h",
"sem/external_texture.h",
"sem/f16.h",
@@ -622,6 +622,7 @@
"sem/depth_multisampled_texture.h",
"sem/depth_texture.cc",
"sem/depth_texture.h",
+ "sem/evaluation_stage.h",
"sem/expression.cc",
"sem/expression.h",
"sem/external_texture.cc",
@@ -1090,9 +1091,11 @@
"resolver/call_validation_test.cc",
"resolver/compound_assignment_validation_test.cc",
"resolver/compound_statement_test.cc",
+ "resolver/const_eval_test.cc",
"resolver/control_block_validation_test.cc",
"resolver/dependency_graph_test.cc",
"resolver/entry_point_validation_test.cc",
+ "resolver/evaluation_stage_test.cc",
"resolver/function_validation_test.cc",
"resolver/host_shareable_validation_test.cc",
"resolver/increment_decrement_validation_test.cc",
@@ -1104,7 +1107,6 @@
"resolver/ptr_ref_test.cc",
"resolver/ptr_ref_validation_test.cc",
"resolver/resolver_behavior_test.cc",
- "resolver/resolver_constants_test.cc",
"resolver/resolver_test.cc",
"resolver/resolver_test_helper.cc",
"resolver/resolver_test_helper.h",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 3e7154c..6c611c3 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -258,7 +258,6 @@
resolver/intrinsic_table.cc
resolver/intrinsic_table.h
resolver/intrinsic_table.inl
- resolver/resolver_constants.cc
resolver/resolver.cc
resolver/resolver.h
resolver/sem_helper.cc
@@ -299,6 +298,7 @@
sem/depth_multisampled_texture.h
sem/depth_texture.cc
sem/depth_texture.h
+ sem/evaluation_stage.h
sem/expression.cc
sem/expression.h
sem/external_texture.cc
@@ -774,9 +774,11 @@
resolver/call_validation_test.cc
resolver/compound_assignment_validation_test.cc
resolver/compound_statement_test.cc
+ resolver/const_eval_test.cc
resolver/control_block_validation_test.cc
resolver/dependency_graph_test.cc
resolver/entry_point_validation_test.cc
+ resolver/evaluation_stage_test.cc
resolver/function_validation_test.cc
resolver/host_shareable_validation_test.cc
resolver/increment_decrement_validation_test.cc
@@ -789,7 +791,6 @@
resolver/ptr_ref_test.cc
resolver/ptr_ref_validation_test.cc
resolver/resolver_behavior_test.cc
- resolver/resolver_constants_test.cc
resolver/resolver_test_helper.cc
resolver/resolver_test_helper.h
resolver/resolver_test.cc
diff --git a/src/tint/intrinsics.def b/src/tint/intrinsics.def
index 17ce925..5dd6168 100644
--- a/src/tint/intrinsics.def
+++ b/src/tint/intrinsics.def
@@ -131,6 +131,7 @@
match fiu32: f32 | i32 | u32
match fi32: f32 | i32
match iu32: i32 | u32
+match aiu32: ai | i32 | u32
match scalar: f32 | f16 | i32 | u32 | bool
match abstract_or_scalar: ai | af | f32 | f16 | i32 | u32 | bool
match af_f32: af | f32
@@ -636,160 +637,166 @@
////////////////////////////////////////////////////////////////////////////////
// Zero value constructors
-ctor i32() -> i32
-ctor u32() -> u32
-ctor f32() -> f32
-ctor f16() -> f16
-ctor bool() -> bool
-ctor vec2<T: scalar>() -> vec2<T>
-ctor vec3<T: scalar>() -> vec3<T>
-ctor vec4<T: scalar>() -> vec4<T>
-ctor mat2x2<T: f32f16>() -> mat2x2<T>
-ctor mat2x3<T: f32f16>() -> mat2x3<T>
-ctor mat2x4<T: f32f16>() -> mat2x4<T>
-ctor mat3x2<T: f32f16>() -> mat3x2<T>
-ctor mat3x3<T: f32f16>() -> mat3x3<T>
-ctor mat3x4<T: f32f16>() -> mat3x4<T>
-ctor mat4x2<T: f32f16>() -> mat4x2<T>
-ctor mat4x3<T: f32f16>() -> mat4x3<T>
-ctor mat4x4<T: f32f16>() -> mat4x4<T>
+@const("Zero") ctor i32() -> i32
+@const("Zero") ctor u32() -> u32
+@const("Zero") ctor f32() -> f32
+@const("Zero") ctor f16() -> f16
+@const("Zero") ctor bool() -> bool
+@const("Zero") ctor vec2<T: scalar>() -> vec2<T>
+@const("Zero") ctor vec3<T: scalar>() -> vec3<T>
+@const("Zero") ctor vec4<T: scalar>() -> vec4<T>
+@const("Zero") ctor mat2x2<T: f32f16>() -> mat2x2<T>
+@const("Zero") ctor mat2x3<T: f32f16>() -> mat2x3<T>
+@const("Zero") ctor mat2x4<T: f32f16>() -> mat2x4<T>
+@const("Zero") ctor mat3x2<T: f32f16>() -> mat3x2<T>
+@const("Zero") ctor mat3x3<T: f32f16>() -> mat3x3<T>
+@const("Zero") ctor mat3x4<T: f32f16>() -> mat3x4<T>
+@const("Zero") ctor mat4x2<T: f32f16>() -> mat4x2<T>
+@const("Zero") ctor mat4x3<T: f32f16>() -> mat4x3<T>
+@const("Zero") ctor mat4x4<T: f32f16>() -> mat4x4<T>
// Identity constructors
-ctor i32(i32) -> i32
-ctor u32(u32) -> u32
-ctor f32(f32) -> f32
-ctor f16(f16) -> f16
-ctor bool(bool) -> bool
-ctor vec2<T: scalar>(vec2<T>) -> vec2<T>
-ctor vec3<T: scalar>(vec3<T>) -> vec3<T>
-ctor vec4<T: scalar>(vec4<T>) -> vec4<T>
-ctor mat2x2<T: f32f16>(mat2x2<T>) -> mat2x2<T>
-ctor mat2x3<T: f32f16>(mat2x3<T>) -> mat2x3<T>
-ctor mat2x4<T: f32f16>(mat2x4<T>) -> mat2x4<T>
-ctor mat3x2<T: f32f16>(mat3x2<T>) -> mat3x2<T>
-ctor mat3x3<T: f32f16>(mat3x3<T>) -> mat3x3<T>
-ctor mat3x4<T: f32f16>(mat3x4<T>) -> mat3x4<T>
-ctor mat4x2<T: f32f16>(mat4x2<T>) -> mat4x2<T>
-ctor mat4x3<T: f32f16>(mat4x3<T>) -> mat4x3<T>
-ctor mat4x4<T: f32f16>(mat4x4<T>) -> mat4x4<T>
+@const("Identity") ctor i32(i32) -> i32
+@const("Identity") ctor u32(u32) -> u32
+@const("Identity") ctor f32(f32) -> f32
+@const("Identity") ctor f16(f16) -> f16
+@const("Identity") ctor bool(bool) -> bool
+@const("Identity") ctor vec2<T: scalar>(vec2<T>) -> vec2<T>
+@const("Identity") ctor vec3<T: scalar>(vec3<T>) -> vec3<T>
+@const("Identity") ctor vec4<T: scalar>(vec4<T>) -> vec4<T>
+@const("Identity") ctor mat2x2<T: f32f16>(mat2x2<T>) -> mat2x2<T>
+@const("Identity") ctor mat2x3<T: f32f16>(mat2x3<T>) -> mat2x3<T>
+@const("Identity") ctor mat2x4<T: f32f16>(mat2x4<T>) -> mat2x4<T>
+@const("Identity") ctor mat3x2<T: f32f16>(mat3x2<T>) -> mat3x2<T>
+@const("Identity") ctor mat3x3<T: f32f16>(mat3x3<T>) -> mat3x3<T>
+@const("Identity") ctor mat3x4<T: f32f16>(mat3x4<T>) -> mat3x4<T>
+@const("Identity") ctor mat4x2<T: f32f16>(mat4x2<T>) -> mat4x2<T>
+@const("Identity") ctor mat4x3<T: f32f16>(mat4x3<T>) -> mat4x3<T>
+@const("Identity") ctor mat4x4<T: f32f16>(mat4x4<T>) -> mat4x4<T>
-// Vector constructors
-ctor vec2<T: abstract_or_scalar>(T) -> vec2<T>
-ctor vec2<T: abstract_or_scalar>(x: T, y: T) -> vec2<T>
-ctor vec3<T: abstract_or_scalar>(T) -> vec3<T>
-ctor vec3<T: abstract_or_scalar>(x: T, y: T, z: T) -> vec3<T>
-ctor vec3<T: abstract_or_scalar>(xy: vec2<T>, z: T) -> vec3<T>
-ctor vec3<T: abstract_or_scalar>(x: T, yz: vec2<T>) -> vec3<T>
-ctor vec4<T: abstract_or_scalar>(T) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(x: T, y: T, z: T, w: T) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(xyz: vec3<T>, w: T) -> vec4<T>
-ctor vec4<T: abstract_or_scalar>(x: T, zyw: vec3<T>) -> vec4<T>
+// Vector constructors (splat)
+@const("VecSplat") ctor vec2<T: abstract_or_scalar>(T) -> vec2<T>
+@const("VecSplat") ctor vec3<T: abstract_or_scalar>(T) -> vec3<T>
+@const("VecSplat") ctor vec4<T: abstract_or_scalar>(T) -> vec4<T>
-// Matrix constructors
-ctor mat2x2<T: af_f32>(T) -> mat2x2<T>
-ctor mat2x3<T: af_f32>(T) -> mat2x3<T>
-ctor mat2x4<T: af_f32>(T) -> mat2x4<T>
-ctor mat3x2<T: af_f32>(T) -> mat3x2<T>
-ctor mat3x3<T: af_f32>(T) -> mat3x3<T>
-ctor mat3x4<T: af_f32>(T) -> mat3x4<T>
-ctor mat4x2<T: af_f32>(T) -> mat4x2<T>
-ctor mat4x3<T: af_f32>(T) -> mat4x3<T>
-ctor mat4x4<T: af_f32>(T) -> mat4x4<T>
+// Vector constructors (scalar)
+@const("VecCtorS") ctor vec2<T: abstract_or_scalar>(x: T, y: T) -> vec2<T>
+@const("VecCtorS") ctor vec3<T: abstract_or_scalar>(x: T, y: T, z: T) -> vec3<T>
+@const("VecCtorS") ctor vec4<T: abstract_or_scalar>(x: T, y: T, z: T, w: T) -> vec4<T>
+// Vector constructors (mixed)
+@const("VecCtorM") ctor vec3<T: abstract_or_scalar>(xy: vec2<T>, z: T) -> vec3<T>
+@const("VecCtorM") ctor vec3<T: abstract_or_scalar>(x: T, yz: vec2<T>) -> vec3<T>
+@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(xyz: vec3<T>, w: T) -> vec4<T>
+@const("VecCtorM") ctor vec4<T: abstract_or_scalar>(x: T, zyw: vec3<T>) -> vec4<T>
+
+// Matrix constructors (scalar)
+@const("MatCtorS")
ctor mat2x2<T: af_f32f16>(T, T,
T, T) -> mat2x2<T>
-ctor mat2x2<T: af_f32f16>(vec2<T>, vec2<T>) -> mat2x2<T>
-
+@const("MatCtorS")
ctor mat2x3<T: af_f32f16>(T, T, T,
T, T, T) -> mat2x3<T>
-ctor mat2x3<T: af_f32f16>(vec3<T>, vec3<T>) -> mat2x3<T>
-
+@const("MatCtorS")
ctor mat2x4<T: af_f32f16>(T, T, T, T,
T, T, T, T) -> mat2x4<T>
-ctor mat2x4<T: af_f32f16>(vec4<T>, vec4<T>) -> mat2x4<T>
-
+@const("MatCtorS")
ctor mat3x2<T: af_f32f16>(T, T,
T, T,
T, T) -> mat3x2<T>
-ctor mat3x2<T: af_f32f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T>
-
+@const("MatCtorS")
ctor mat3x3<T: af_f32f16>(T, T, T,
T, T, T,
T, T, T) -> mat3x3<T>
-ctor mat3x3<T: af_f32f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T>
-
+@const("MatCtorS")
ctor mat3x4<T: af_f32f16>(T, T, T, T,
T, T, T, T,
T, T, T, T) -> mat3x4<T>
-ctor mat3x4<T: af_f32f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T>
-
+@const("MatCtorS")
ctor mat4x2<T: af_f32f16>(T, T,
T, T,
T, T,
T, T) -> mat4x2<T>
-ctor mat4x2<T: af_f32f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T>
-
+@const("MatCtorS")
ctor mat4x3<T: af_f32f16>(T, T, T,
T, T, T,
T, T, T,
T, T, T) -> mat4x3<T>
-ctor mat4x3<T: af_f32f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T>
-
+@const("MatCtorS")
ctor mat4x4<T: af_f32f16>(T, T, T, T,
T, T, T, T,
T, T, T, T,
T, T, T, T) -> mat4x4<T>
+
+// Matrix constructors (column vectors)
+@const("MatCtorV")
+ctor mat2x2<T: af_f32f16>(vec2<T>, vec2<T>) -> mat2x2<T>
+@const("MatCtorV")
+ctor mat2x3<T: af_f32f16>(vec3<T>, vec3<T>) -> mat2x3<T>
+@const("MatCtorV")
+ctor mat2x4<T: af_f32f16>(vec4<T>, vec4<T>) -> mat2x4<T>
+@const("MatCtorV")
+ctor mat3x2<T: af_f32f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T>
+@const("MatCtorV")
+ctor mat3x3<T: af_f32f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T>
+@const("MatCtorV")
+ctor mat3x4<T: af_f32f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T>
+@const("MatCtorV")
+ctor mat4x2<T: af_f32f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T>
+@const("MatCtorV")
+ctor mat4x3<T: af_f32f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T>
+@const("MatCtorV")
ctor mat4x4<T: af_f32f16>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T>
////////////////////////////////////////////////////////////////////////////////
// Type conversions //
////////////////////////////////////////////////////////////////////////////////
-conv f32<T: scalar_no_f32>(T) -> f32
-conv f16<T: scalar_no_f16>(T) -> f16
-conv i32<T: scalar_no_i32>(T) -> i32
-conv u32<T: scalar_no_u32>(T) -> u32
-conv bool<T: scalar_no_bool>(T) -> bool
+@const conv f32<T: scalar_no_f32>(T) -> f32
+@const conv f16<T: scalar_no_f16>(T) -> f16
+@const conv i32<T: scalar_no_i32>(T) -> i32
+@const conv u32<T: scalar_no_u32>(T) -> u32
+@const conv bool<T: scalar_no_bool>(T) -> bool
-conv vec2<T: f32, U: scalar_no_f32>(vec2<U>) -> vec2<f32>
-conv vec2<T: f16, U: scalar_no_f16>(vec2<U>) -> vec2<f16>
-conv vec2<T: i32, U: scalar_no_i32>(vec2<U>) -> vec2<i32>
-conv vec2<T: u32, U: scalar_no_u32>(vec2<U>) -> vec2<u32>
-conv vec2<T: bool, U: scalar_no_bool>(vec2<U>) -> vec2<bool>
+@const conv vec2<T: f32, U: scalar_no_f32>(vec2<U>) -> vec2<f32>
+@const conv vec2<T: f16, U: scalar_no_f16>(vec2<U>) -> vec2<f16>
+@const conv vec2<T: i32, U: scalar_no_i32>(vec2<U>) -> vec2<i32>
+@const conv vec2<T: u32, U: scalar_no_u32>(vec2<U>) -> vec2<u32>
+@const conv vec2<T: bool, U: scalar_no_bool>(vec2<U>) -> vec2<bool>
-conv vec3<T: f32, U: scalar_no_f32>(vec3<U>) -> vec3<f32>
-conv vec3<T: f16, U: scalar_no_f16>(vec3<U>) -> vec3<f16>
-conv vec3<T: i32, U: scalar_no_i32>(vec3<U>) -> vec3<i32>
-conv vec3<T: u32, U: scalar_no_u32>(vec3<U>) -> vec3<u32>
-conv vec3<T: bool, U: scalar_no_bool>(vec3<U>) -> vec3<bool>
+@const conv vec3<T: f32, U: scalar_no_f32>(vec3<U>) -> vec3<f32>
+@const conv vec3<T: f16, U: scalar_no_f16>(vec3<U>) -> vec3<f16>
+@const conv vec3<T: i32, U: scalar_no_i32>(vec3<U>) -> vec3<i32>
+@const conv vec3<T: u32, U: scalar_no_u32>(vec3<U>) -> vec3<u32>
+@const conv vec3<T: bool, U: scalar_no_bool>(vec3<U>) -> vec3<bool>
-conv vec4<T: f32, U: scalar_no_f32>(vec4<U>) -> vec4<f32>
-conv vec4<T: f16, U: scalar_no_f16>(vec4<U>) -> vec4<f16>
-conv vec4<T: i32, U: scalar_no_i32>(vec4<U>) -> vec4<i32>
-conv vec4<T: u32, U: scalar_no_u32>(vec4<U>) -> vec4<u32>
-conv vec4<T: bool, U: scalar_no_bool>(vec4<U>) -> vec4<bool>
+@const conv vec4<T: f32, U: scalar_no_f32>(vec4<U>) -> vec4<f32>
+@const conv vec4<T: f16, U: scalar_no_f16>(vec4<U>) -> vec4<f16>
+@const conv vec4<T: i32, U: scalar_no_i32>(vec4<U>) -> vec4<i32>
+@const conv vec4<T: u32, U: scalar_no_u32>(vec4<U>) -> vec4<u32>
+@const conv vec4<T: bool, U: scalar_no_bool>(vec4<U>) -> vec4<bool>
-conv mat2x2<T: f16>(mat2x2<f32>) -> mat2x2<f16>
-conv mat2x2<T: f32>(mat2x2<f16>) -> mat2x2<f32>
-conv mat2x3<T: f16>(mat2x3<f32>) -> mat2x3<f16>
-conv mat2x3<T: f32>(mat2x3<f16>) -> mat2x3<f32>
-conv mat2x4<T: f16>(mat2x4<f32>) -> mat2x4<f16>
-conv mat2x4<T: f32>(mat2x4<f16>) -> mat2x4<f32>
-conv mat3x2<T: f16>(mat3x2<f32>) -> mat3x2<f16>
-conv mat3x2<T: f32>(mat3x2<f16>) -> mat3x2<f32>
-conv mat3x3<T: f16>(mat3x3<f32>) -> mat3x3<f16>
-conv mat3x3<T: f32>(mat3x3<f16>) -> mat3x3<f32>
-conv mat3x4<T: f16>(mat3x4<f32>) -> mat3x4<f16>
-conv mat3x4<T: f32>(mat3x4<f16>) -> mat3x4<f32>
-conv mat4x2<T: f16>(mat4x2<f32>) -> mat4x2<f16>
-conv mat4x2<T: f32>(mat4x2<f16>) -> mat4x2<f32>
-conv mat4x3<T: f16>(mat4x3<f32>) -> mat4x3<f16>
-conv mat4x3<T: f32>(mat4x3<f16>) -> mat4x3<f32>
-conv mat4x4<T: f16>(mat4x4<f32>) -> mat4x4<f16>
-conv mat4x4<T: f32>(mat4x4<f16>) -> mat4x4<f32>
+@const conv mat2x2<T: f16>(mat2x2<f32>) -> mat2x2<f16>
+@const conv mat2x2<T: f32>(mat2x2<f16>) -> mat2x2<f32>
+@const conv mat2x3<T: f16>(mat2x3<f32>) -> mat2x3<f16>
+@const conv mat2x3<T: f32>(mat2x3<f16>) -> mat2x3<f32>
+@const conv mat2x4<T: f16>(mat2x4<f32>) -> mat2x4<f16>
+@const conv mat2x4<T: f32>(mat2x4<f16>) -> mat2x4<f32>
+@const conv mat3x2<T: f16>(mat3x2<f32>) -> mat3x2<f16>
+@const conv mat3x2<T: f32>(mat3x2<f16>) -> mat3x2<f32>
+@const conv mat3x3<T: f16>(mat3x3<f32>) -> mat3x3<f16>
+@const conv mat3x3<T: f32>(mat3x3<f16>) -> mat3x3<f32>
+@const conv mat3x4<T: f16>(mat3x4<f32>) -> mat3x4<f16>
+@const conv mat3x4<T: f32>(mat3x4<f16>) -> mat3x4<f32>
+@const conv mat4x2<T: f16>(mat4x2<f32>) -> mat4x2<f16>
+@const conv mat4x2<T: f32>(mat4x2<f16>) -> mat4x2<f32>
+@const conv mat4x3<T: f16>(mat4x3<f32>) -> mat4x3<f16>
+@const conv mat4x3<T: f32>(mat4x3<f16>) -> mat4x3<f32>
+@const conv mat4x4<T: f16>(mat4x4<f32>) -> mat4x4<f16>
+@const conv mat4x4<T: f32>(mat4x4<f16>) -> mat4x4<f32>
////////////////////////////////////////////////////////////////////////////////
// Operators //
@@ -810,8 +817,8 @@
op ! (bool) -> bool
op ! <N: num> (vec<N, bool>) -> vec<N, bool>
-op ~ <T: iu32>(T) -> T
-op ~ <T: iu32, N: num> (vec<N, T>) -> vec<N, T>
+@const op ~ <T: aiu32>(T) -> T
+@const op ~ <T: aiu32, N: num> (vec<N, T>) -> vec<N, T>
op - <T: fi32>(T) -> T
op - <T: fi32, N: num> (vec<N, T>) -> vec<N, T>
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index e9b0a80..9a4f7ca 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -780,6 +780,17 @@
}
/// @param source the Source of the node
+ /// @param storage_class the storage class of the pointer
+ /// @param access the optional access control of the pointer
+ /// @return the pointer to type `T` with the given ast::StorageClass.
+ template <typename T>
+ const ast::Pointer* pointer(const Source& source,
+ ast::StorageClass storage_class,
+ ast::Access access = ast::Access::kUndefined) const {
+ return pointer(source, Of<T>(), storage_class, access);
+ }
+
+ /// @param source the Source of the node
/// @param type the type of the atomic
/// @return the atomic to `type`
const ast::Atomic* atomic(const Source& source, const ast::Type* type) const {
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index fac2c7d..4a8c097 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -14,6 +14,660 @@
#include "src/tint/resolver/const_eval.h"
-#include "src/tint/sem/constant.h"
+#include <algorithm>
+#include <limits>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <utility>
-namespace tint::resolver::const_eval {} // namespace tint::resolver::const_eval
+#include "src/tint/program_builder.h"
+#include "src/tint/sem/abstract_float.h"
+#include "src/tint/sem/abstract_int.h"
+#include "src/tint/sem/array.h"
+#include "src/tint/sem/bool.h"
+#include "src/tint/sem/constant.h"
+#include "src/tint/sem/f16.h"
+#include "src/tint/sem/f32.h"
+#include "src/tint/sem/i32.h"
+#include "src/tint/sem/matrix.h"
+#include "src/tint/sem/member_accessor_expression.h"
+#include "src/tint/sem/type_constructor.h"
+#include "src/tint/sem/u32.h"
+#include "src/tint/sem/vector.h"
+#include "src/tint/utils/compiler_macros.h"
+#include "src/tint/utils/map.h"
+#include "src/tint/utils/transform.h"
+
+using namespace tint::number_suffixes; // NOLINT
+
+namespace tint::resolver {
+
+namespace {
+
+/// TypeDispatch is a helper for calling the function `f`, passing a single zero-value argument of
+/// the C++ type that corresponds to the sem::Type `type`. For example, calling `TypeDispatch()`
+/// with a type of `sem::I32*` will call the function f with a single argument of `i32(0)`.
+/// @returns the value returned by calling `f`.
+/// @note `type` must be a scalar or abstract numeric type. Other types will not call `f`, and will
+/// return the zero-initialized value of the return type for `f`.
+template <typename F>
+auto TypeDispatch(const sem::Type* type, F&& f) {
+ return Switch(
+ type, //
+ [&](const sem::AbstractInt*) { return f(AInt(0)); }, //
+ [&](const sem::AbstractFloat*) { return f(AFloat(0)); }, //
+ [&](const sem::I32*) { return f(i32(0)); }, //
+ [&](const sem::U32*) { return f(u32(0)); }, //
+ [&](const sem::F32*) { return f(f32(0)); }, //
+ [&](const sem::F16*) { return f(f16(0)); }, //
+ [&](const sem::Bool*) { return f(static_cast<bool>(0)); });
+}
+
+/// IntegerDispatch is a helper for calling the function `f`, passing the integer value of the
+/// constant c.
+/// @returns the value returned by calling `f`.
+/// @note `c` must be of an integer type. Other types will not call `f`, and will return the
+/// zero-initialized value of the return type for `f`
+template <typename F>
+auto IntegerDispatch(const sem::Constant* c, F&& f) {
+ return Switch(
+ c->Type(), //
+ [&](const sem::AbstractInt*) { return f(c->As<AInt>()); }, //
+ [&](const sem::I32*) { return f(c->As<i32>()); }, //
+ [&](const sem::U32*) { return f(c->As<u32>()); });
+}
+
+/// @returns `value` if `T` is not a Number, otherwise ValueOf returns the inner value of the
+/// Number.
+template <typename T>
+inline auto ValueOf(T value) {
+ if constexpr (std::is_same_v<UnwrapNumber<T>, T>) {
+ return value;
+ } else {
+ return value.value;
+ }
+}
+
+/// @returns true if `value` is a positive zero.
+template <typename T>
+inline bool IsPositiveZero(T value) {
+ using N = UnwrapNumber<T>;
+ return Number<N>(value) == Number<N>(0); // Considers sign bit
+}
+
+/// Constant inherits from sem::Constant to add an private implementation method for conversion.
+struct Constant : public sem::Constant {
+ /// Convert attempts to convert the constant value to the given type. On error, Convert()
+ /// creates a new diagnostic message and returns a Failure.
+ virtual utils::Result<const Constant*> Convert(ProgramBuilder& builder,
+ const sem::Type* target_ty,
+ const Source& source) const = 0;
+};
+
+// Forward declaration
+const Constant* CreateComposite(ProgramBuilder& builder,
+ const sem::Type* type,
+ std::vector<const sem::Constant*> elements);
+
+/// Element holds a single scalar or abstract-numeric value.
+/// Element implements the Constant interface.
+template <typename T>
+struct Element : Constant {
+ static_assert(!std::is_same_v<UnwrapNumber<T>, T> || std::is_same_v<T, bool>,
+ "T must be a Number or bool");
+
+ Element(const sem::Type* t, T v) : type(t), value(v) {}
+ ~Element() override = default;
+ const sem::Type* Type() const override { return type; }
+ std::variant<std::monostate, AInt, AFloat> Value() const override {
+ if constexpr (IsFloatingPoint<UnwrapNumber<T>>) {
+ return static_cast<AFloat>(value);
+ } else {
+ return static_cast<AInt>(value);
+ }
+ }
+ const sem::Constant* Index(size_t) const override { return nullptr; }
+ bool AllZero() const override { return IsPositiveZero(value); }
+ bool AnyZero() const override { return IsPositiveZero(value); }
+ bool AllEqual() const override { return true; }
+ size_t Hash() const override { return utils::Hash(type, ValueOf(value)); }
+
+ utils::Result<const Constant*> Convert(ProgramBuilder& builder,
+ const sem::Type* target_ty,
+ const Source& source) const override {
+ TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
+ if (target_ty == type) {
+ // If the types are identical, then no conversion is needed.
+ return this;
+ }
+ bool failed = false;
+ auto* res = TypeDispatch(target_ty, [&](auto zero_to) -> const Constant* {
+ // `T` is the source type, `value` is the source value.
+ // `TO` is the target type.
+ using TO = std::decay_t<decltype(zero_to)>;
+ if constexpr (std::is_same_v<TO, bool>) {
+ // [x -> bool]
+ return builder.create<Element<TO>>(target_ty, !IsPositiveZero(value));
+ } else if constexpr (std::is_same_v<T, bool>) {
+ // [bool -> x]
+ return builder.create<Element<TO>>(target_ty, TO(value ? 1 : 0));
+ } else if (auto conv = CheckedConvert<TO>(value)) {
+ // Conversion success
+ return builder.create<Element<TO>>(target_ty, conv.Get());
+ // --- Below this point are the failure cases ---
+ } else if constexpr (std::is_same_v<T, AInt> || std::is_same_v<T, AFloat>) {
+ // [abstract-numeric -> x] - materialization failure
+ std::stringstream ss;
+ ss << "value " << value << " cannot be represented as ";
+ ss << "'" << builder.FriendlyName(target_ty) << "'";
+ builder.Diagnostics().add_error(tint::diag::System::Resolver, ss.str(), source);
+ failed = true;
+ } else if constexpr (IsFloatingPoint<UnwrapNumber<TO>>) {
+ // [x -> floating-point] - number not exactly representable
+ // https://www.w3.org/TR/WGSL/#floating-point-conversion
+ constexpr auto kInf = std::numeric_limits<double>::infinity();
+ switch (conv.Failure()) {
+ case ConversionFailure::kExceedsNegativeLimit:
+ return builder.create<Element<TO>>(target_ty, TO(-kInf));
+ case ConversionFailure::kExceedsPositiveLimit:
+ return builder.create<Element<TO>>(target_ty, TO(kInf));
+ }
+ } else {
+ // [x -> integer] - number not exactly representable
+ // https://www.w3.org/TR/WGSL/#floating-point-conversion
+ switch (conv.Failure()) {
+ case ConversionFailure::kExceedsNegativeLimit:
+ return builder.create<Element<TO>>(target_ty, TO(TO::kLowest));
+ case ConversionFailure::kExceedsPositiveLimit:
+ return builder.create<Element<TO>>(target_ty, TO(TO::kHighest));
+ }
+ }
+ return nullptr; // Expression is not constant.
+ });
+ if (failed) {
+ // A diagnostic error has been raised, and resolving should abort.
+ return utils::Failure;
+ }
+ return res;
+ TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
+ }
+
+ sem::Type const* const type;
+ const T value;
+};
+
+/// Splat holds a single Constant value, duplicated as all children.
+/// Splat is used for zero-initializers, 'splat' constructors, or constructors where each element is
+/// identical. Splat may be of a vector, matrix or array type.
+/// Splat implements the Constant interface.
+struct Splat : Constant {
+ Splat(const sem::Type* t, const sem::Constant* e, size_t n) : type(t), el(e), count(n) {}
+ ~Splat() override = default;
+ const sem::Type* Type() const override { return type; }
+ std::variant<std::monostate, AInt, AFloat> Value() const override { return {}; }
+ const sem::Constant* Index(size_t i) const override { return i < count ? el : nullptr; }
+ bool AllZero() const override { return el->AllZero(); }
+ bool AnyZero() const override { return el->AnyZero(); }
+ bool AllEqual() const override { return true; }
+ size_t Hash() const override { return utils::Hash(type, el->Hash(), count); }
+
+ utils::Result<const Constant*> Convert(ProgramBuilder& builder,
+ const sem::Type* target_ty,
+ const Source& source) const override {
+ // Convert the single splatted element type.
+ // Note: This file is the only place where `sem::Constant`s are created, so this static_cast
+ // is safe.
+ auto conv_el = static_cast<const Constant*>(el)->Convert(
+ builder, sem::Type::ElementOf(target_ty), source);
+ if (!conv_el) {
+ return utils::Failure;
+ }
+ if (!conv_el.Get()) {
+ return nullptr;
+ }
+ return builder.create<Splat>(target_ty, conv_el.Get(), count);
+ }
+
+ sem::Type const* const type;
+ const sem::Constant* el;
+ const size_t count;
+};
+
+/// Composite holds a number of mixed child Constant values.
+/// Composite may be of a vector, matrix or array type.
+/// If each element is the same type and value, then a Splat would be a more efficient constant
+/// implementation. Use CreateComposite() to create the appropriate Constant type.
+/// Composite implements the Constant interface.
+struct Composite : Constant {
+ Composite(const sem::Type* t, std::vector<const sem::Constant*> els, bool all_0, bool any_0)
+ : type(t), elements(std::move(els)), all_zero(all_0), any_zero(any_0), hash(CalcHash()) {}
+ ~Composite() override = default;
+ const sem::Type* Type() const override { return type; }
+ std::variant<std::monostate, AInt, AFloat> Value() const override { return {}; }
+ const sem::Constant* Index(size_t i) const override {
+ return i < elements.size() ? elements[i] : nullptr;
+ }
+ bool AllZero() const override { return all_zero; }
+ bool AnyZero() const override { return any_zero; }
+ bool AllEqual() const override { return false; /* otherwise this should be a Splat */ }
+ size_t Hash() const override { return hash; }
+
+ utils::Result<const Constant*> Convert(ProgramBuilder& builder,
+ const sem::Type* target_ty,
+ const Source& source) const override {
+ // Convert each of the composite element types.
+ auto* el_ty = sem::Type::ElementOf(target_ty);
+ std::vector<const sem::Constant*> conv_els;
+ conv_els.reserve(elements.size());
+ for (auto* el : elements) {
+ // Note: This file is the only place where `sem::Constant`s are created, so this
+ // static_cast is safe.
+ auto conv_el = static_cast<const Constant*>(el)->Convert(builder, el_ty, source);
+ if (!conv_el) {
+ return utils::Failure;
+ }
+ if (!conv_el.Get()) {
+ return nullptr;
+ }
+ conv_els.emplace_back(conv_el.Get());
+ }
+ return CreateComposite(builder, target_ty, std::move(conv_els));
+ }
+
+ size_t CalcHash() {
+ auto h = utils::Hash(type, all_zero, any_zero);
+ for (auto* el : elements) {
+ utils::HashCombine(&h, el->Hash());
+ }
+ return h;
+ }
+
+ sem::Type const* const type;
+ const std::vector<const sem::Constant*> elements;
+ const bool all_zero;
+ const bool any_zero;
+ const size_t hash;
+};
+
+/// CreateElement constructs and returns an Element<T>.
+template <typename T>
+const Constant* CreateElement(ProgramBuilder& builder, const sem::Type* t, T v) {
+ return builder.create<Element<T>>(t, v);
+}
+
+/// ZeroValue returns a Constant for the zero-value of the type `type`.
+const Constant* ZeroValue(ProgramBuilder& builder, const sem::Type* type) {
+ return Switch(
+ type, //
+ [&](const sem::Vector* v) -> const Constant* {
+ auto* zero_el = ZeroValue(builder, v->type());
+ return builder.create<Splat>(type, zero_el, v->Width());
+ },
+ [&](const sem::Matrix* m) -> const Constant* {
+ auto* zero_el = ZeroValue(builder, m->ColumnType());
+ return builder.create<Splat>(type, zero_el, m->columns());
+ },
+ [&](const sem::Array* a) -> const Constant* {
+ if (auto* zero_el = ZeroValue(builder, a->ElemType())) {
+ return builder.create<Splat>(type, zero_el, a->Count());
+ }
+ return nullptr;
+ },
+ [&](const sem::Struct* s) -> const Constant* {
+ std::unordered_map<sem::Type*, const Constant*> zero_by_type;
+ std::vector<const sem::Constant*> zeros;
+ zeros.reserve(s->Members().size());
+ for (auto* member : s->Members()) {
+ auto* zero = utils::GetOrCreate(zero_by_type, member->Type(),
+ [&] { return ZeroValue(builder, member->Type()); });
+ if (!zero) {
+ return nullptr;
+ }
+ zeros.emplace_back(zero);
+ }
+ if (zero_by_type.size() == 1) {
+ // All members were of the same type, so the zero value is the same for all members.
+ return builder.create<Splat>(type, zeros[0], s->Members().size());
+ }
+ return CreateComposite(builder, s, std::move(zeros));
+ },
+ [&](Default) -> const Constant* {
+ return TypeDispatch(type, [&](auto zero) -> const Constant* {
+ return CreateElement(builder, type, zero);
+ });
+ });
+}
+
+/// Equal returns true if the constants `a` and `b` are of the same type and value.
+bool Equal(const sem::Constant* a, const sem::Constant* b) {
+ if (a->Hash() != b->Hash()) {
+ return false;
+ }
+ if (a->Type() != b->Type()) {
+ return false;
+ }
+ return Switch(
+ a->Type(), //
+ [&](const sem::Vector* vec) {
+ for (size_t i = 0; i < vec->Width(); i++) {
+ if (!Equal(a->Index(i), b->Index(i))) {
+ return false;
+ }
+ }
+ return true;
+ },
+ [&](const sem::Matrix* mat) {
+ for (size_t i = 0; i < mat->columns(); i++) {
+ if (!Equal(a->Index(i), b->Index(i))) {
+ return false;
+ }
+ }
+ return true;
+ },
+ [&](const sem::Array* arr) {
+ for (size_t i = 0; i < arr->Count(); i++) {
+ if (!Equal(a->Index(i), b->Index(i))) {
+ return false;
+ }
+ }
+ return true;
+ },
+ [&](Default) { return a->Value() == b->Value(); });
+}
+
+/// CreateComposite is used to construct a constant of a vector, matrix or array type.
+/// CreateComposite examines the element values and will return either a Composite or a Splat,
+/// depending on the element types and values.
+const Constant* CreateComposite(ProgramBuilder& builder,
+ const sem::Type* type,
+ std::vector<const sem::Constant*> elements) {
+ if (elements.size() == 0) {
+ return nullptr;
+ }
+ bool any_zero = false;
+ bool all_zero = true;
+ bool all_equal = true;
+ auto* first = elements.front();
+ for (auto* el : elements) {
+ if (!el) {
+ return nullptr;
+ }
+ if (!any_zero && el->AnyZero()) {
+ any_zero = true;
+ }
+ if (all_zero && !el->AllZero()) {
+ all_zero = false;
+ }
+ if (all_equal && el != first) {
+ if (!Equal(el, first)) {
+ all_equal = false;
+ }
+ }
+ }
+ if (all_equal) {
+ return builder.create<Splat>(type, elements[0], elements.size());
+ } else {
+ return builder.create<Composite>(type, std::move(elements), all_zero, any_zero);
+ }
+}
+
+/// TransformElements constructs a new constant by applying the transformation function 'f' on each
+/// of the most deeply nested elements of 'c'.
+template <typename F>
+const Constant* TransformElements(ProgramBuilder& builder, const sem::Constant* c, F&& f) {
+ uint32_t n = 0;
+ auto* ty = c->Type();
+ auto* el_ty = sem::Type::ElementOf(ty, &n);
+ if (el_ty == ty) {
+ return f(c);
+ }
+ std::vector<const sem::Constant*> els(n);
+ for (uint32_t i = 0; i < n; i++) {
+ els[i] = TransformElements(builder, c->Index(i), f);
+ }
+ return CreateComposite(builder, c->Type(), std::move(els));
+}
+
+} // namespace
+
+ConstEval::ConstEval(ProgramBuilder& b) : builder(b) {}
+
+const sem::Constant* ConstEval::Literal(const sem::Type* ty,
+ const ast::LiteralExpression* literal) {
+ return Switch(
+ literal,
+ [&](const ast::BoolLiteralExpression* lit) {
+ return CreateElement(builder, ty, lit->value);
+ },
+ [&](const ast::IntLiteralExpression* lit) -> const Constant* {
+ switch (lit->suffix) {
+ case ast::IntLiteralExpression::Suffix::kNone:
+ return CreateElement(builder, ty, AInt(lit->value));
+ case ast::IntLiteralExpression::Suffix::kI:
+ return CreateElement(builder, ty, i32(lit->value));
+ case ast::IntLiteralExpression::Suffix::kU:
+ return CreateElement(builder, ty, u32(lit->value));
+ }
+ return nullptr;
+ },
+ [&](const ast::FloatLiteralExpression* lit) -> const Constant* {
+ switch (lit->suffix) {
+ case ast::FloatLiteralExpression::Suffix::kNone:
+ return CreateElement(builder, ty, AFloat(lit->value));
+ case ast::FloatLiteralExpression::Suffix::kF:
+ return CreateElement(builder, ty, f32(lit->value));
+ case ast::FloatLiteralExpression::Suffix::kH:
+ return CreateElement(builder, ty, f16(lit->value));
+ }
+ return nullptr;
+ });
+}
+
+const sem::Constant* ConstEval::ArrayOrStructCtor(const sem::Type* ty,
+ const std::vector<const sem::Expression*>& args) {
+ if (args.empty()) {
+ return ZeroValue(builder, ty);
+ }
+
+ if (args.size() == 1 && args[0]->Type() == ty) {
+ // Identity constructor.
+ return args[0]->ConstantValue();
+ }
+
+ // Multiple arguments. Must be a type constructor.
+ std::vector<const sem::Constant*> els;
+ els.reserve(args.size());
+ for (auto* arg : args) {
+ els.emplace_back(arg->ConstantValue());
+ }
+ return CreateComposite(builder, ty, std::move(els));
+}
+
+const sem::Constant* ConstEval::Conv(const sem::Type* ty, ArgumentList args, size_t) {
+ uint32_t el_count = 0;
+ auto* el_ty = sem::Type::ElementOf(ty, &el_count);
+ if (!el_ty) {
+ return nullptr;
+ }
+
+ auto& src = args[0]->Declaration()->source;
+ auto* arg = args[0]->ConstantValue();
+ if (!arg) {
+ return nullptr; // Single argument is not constant.
+ }
+
+ if (auto conv = Convert(ty, arg, src)) {
+ return conv.Get();
+ }
+
+ return nullptr;
+}
+
+const sem::Constant* ConstEval::Zero(const sem::Type* ty, ArgumentList, size_t) {
+ return ZeroValue(builder, ty);
+}
+
+const sem::Constant* ConstEval::Identity(const sem::Type*, ArgumentList args, size_t) {
+ return args[0]->ConstantValue();
+}
+
+const sem::Constant* ConstEval::VecSplat(const sem::Type* ty,
+ sem::Expression const* const* args,
+ size_t) {
+ if (auto* arg = args[0]->ConstantValue()) {
+ return builder.create<Splat>(ty, arg, static_cast<const sem::Vector*>(ty)->Width());
+ }
+ return nullptr;
+}
+
+const sem::Constant* ConstEval::VecCtorS(const sem::Type* ty, ArgumentList args, size_t num_args) {
+ std::vector<const sem::Constant*> els;
+ els.reserve(num_args);
+ for (size_t i = 0; i < num_args; i++) {
+ els.emplace_back(args[i]->ConstantValue());
+ }
+ return CreateComposite(builder, ty, std::move(els));
+}
+
+const sem::Constant* ConstEval::VecCtorM(const sem::Type* ty, ArgumentList args, size_t num_args) {
+ std::vector<const sem::Constant*> els;
+ els.reserve(num_args);
+ for (size_t i = 0; i < num_args; i++) {
+ auto* arg = args[i]->ConstantValue();
+ if (!arg) {
+ return nullptr;
+ }
+ auto* arg_ty = arg->Type();
+ if (auto* arg_vec = arg_ty->As<sem::Vector>()) {
+ // Extract out vector elements.
+ for (uint32_t j = 0; j < arg_vec->Width(); j++) {
+ auto* el = arg->Index(j);
+ if (!el) {
+ return nullptr;
+ }
+ els.emplace_back(el);
+ }
+ } else {
+ els.emplace_back(arg);
+ }
+ }
+ return CreateComposite(builder, ty, std::move(els));
+}
+
+const sem::Constant* ConstEval::MatCtorS(const sem::Type* ty, ArgumentList args, size_t num_args) {
+ auto* m = static_cast<const sem::Matrix*>(ty);
+
+ std::vector<const sem::Constant*> els;
+ els.reserve(num_args);
+ for (uint32_t c = 0; c < m->columns(); c++) {
+ std::vector<const sem::Constant*> column;
+ column.reserve(m->rows());
+ for (uint32_t r = 0; r < m->rows(); r++) {
+ auto i = r + c * m->rows();
+ column.emplace_back(args[i]->ConstantValue());
+ }
+ els.push_back(CreateComposite(builder, m->ColumnType(), std::move(column)));
+ }
+ return CreateComposite(builder, ty, std::move(els));
+}
+
+const sem::Constant* ConstEval::MatCtorV(const sem::Type* ty, ArgumentList args, size_t num_args) {
+ std::vector<const sem::Constant*> els;
+ els.reserve(num_args);
+ for (size_t i = 0; i < num_args; i++) {
+ els.emplace_back(args[i]->ConstantValue());
+ }
+ return CreateComposite(builder, ty, std::move(els));
+}
+
+const sem::Constant* ConstEval::Index(const sem::Expression* obj_expr,
+ const sem::Expression* idx_expr) {
+ auto obj_val = obj_expr->ConstantValue();
+ if (!obj_val) {
+ return {};
+ }
+
+ auto idx_val = idx_expr->ConstantValue();
+ if (!idx_val) {
+ return {};
+ }
+
+ uint32_t el_count = 0;
+ sem::Type::ElementOf(obj_val->Type(), &el_count);
+
+ AInt idx = idx_val->As<AInt>();
+ if (idx < 0 || idx >= el_count) {
+ auto clamped = std::min<AInt::type>(std::max<AInt::type>(idx, 0), el_count - 1);
+ AddWarning("index " + std::to_string(idx) + " out of bounds [0.." +
+ std::to_string(el_count - 1) + "]. Clamping index to " +
+ std::to_string(clamped),
+ idx_expr->Declaration()->source);
+ idx = clamped;
+ }
+
+ return obj_val->Index(static_cast<size_t>(idx));
+}
+
+const sem::Constant* ConstEval::MemberAccess(const sem::Expression* obj_expr,
+ const sem::StructMember* member) {
+ auto obj_val = obj_expr->ConstantValue();
+ if (!obj_val) {
+ return {};
+ }
+ return obj_val->Index(static_cast<size_t>(member->Index()));
+}
+
+const sem::Constant* ConstEval::Swizzle(const sem::Type* ty,
+ const sem::Expression* vec_expr,
+ const std::vector<uint32_t>& indices) {
+ auto* vec_val = vec_expr->ConstantValue();
+ if (!vec_val) {
+ return nullptr;
+ }
+ if (indices.size() == 1) {
+ return vec_val->Index(static_cast<size_t>(indices[0]));
+ } else {
+ auto values = utils::Transform(
+ indices, [&](uint32_t i) { return vec_val->Index(static_cast<size_t>(i)); });
+ return CreateComposite(builder, ty, std::move(values));
+ }
+}
+
+const sem::Constant* ConstEval::Bitcast(const sem::Type*, const sem::Expression*) {
+ // TODO(crbug.com/tint/1581): Implement @const intrinsics
+ return nullptr;
+}
+
+const sem::Constant* ConstEval::OpComplement(const sem::Type*,
+ sem::Expression const* const* args,
+ size_t) {
+ return TransformElements(builder, args[0]->ConstantValue(), [&](const sem::Constant* c) {
+ return IntegerDispatch(c, [&](auto i) { //
+ return CreateElement(builder, c->Type(), decltype(i)(~i.value));
+ });
+ });
+}
+
+utils::Result<const sem::Constant*> ConstEval::Convert(const sem::Type* target_ty,
+ const sem::Constant* value,
+ const Source& source) {
+ if (value->Type() == target_ty) {
+ return value;
+ }
+ auto conv = static_cast<const Constant*>(value)->Convert(builder, target_ty, source);
+ if (!conv) {
+ return utils::Failure;
+ }
+ return conv.Get();
+}
+
+void ConstEval::AddError(const std::string& msg, const Source& source) const {
+ builder.Diagnostics().add_error(diag::System::Resolver, msg, source);
+}
+
+void ConstEval::AddWarning(const std::string& msg, const Source& source) const {
+ builder.Diagnostics().add_warning(diag::System::Resolver, msg, source);
+}
+
+} // namespace tint::resolver
diff --git a/src/tint/resolver/const_eval.h b/src/tint/resolver/const_eval.h
index 3792e35..b1e7352 100644
--- a/src/tint/resolver/const_eval.h
+++ b/src/tint/resolver/const_eval.h
@@ -16,24 +16,187 @@
#define SRC_TINT_RESOLVER_CONST_EVAL_H_
#include <stddef.h>
+#include <string>
+#include <vector>
+
+#include "src/tint/utils/result.h"
// Forward declarations
namespace tint {
class ProgramBuilder;
+class Source;
} // namespace tint
-
-// Forward declarations
+namespace tint::ast {
+class LiteralExpression;
+} // namespace tint::ast
namespace tint::sem {
class Constant;
+class Expression;
+class StructMember;
+class Type;
} // namespace tint::sem
-namespace tint::resolver::const_eval {
+namespace tint::resolver {
-/// Typedef for a constant evaluation function
-using Function = const sem::Constant*(ProgramBuilder& builder,
- sem::Constant const* const* args,
+/// ConstEval performs shader creation-time (constant expression) expression evaluation.
+/// Methods are called from the resolver, either directly or via member-function pointers indexed by
+/// the IntrinsicTable. All child-expression nodes are guaranteed to have been already resolved
+/// before calling a method to evaluate an expression's value.
+class ConstEval {
+ public:
+ /// Typedef for a pointer to an array of `const sem::Expression*`, where each expression is an
+ /// argument to the function.
+ using ArgumentList = sem::Expression const* const*;
+
+ /// Typedef for a constant evaluation function
+ using Function = const sem::Constant* (ConstEval::*)(const sem::Type* result_ty,
+ ArgumentList args,
+ size_t num_args);
+
+ /// The result type of a method that may raise a diagnostic error and the caller should abort
+ /// resolving. Can be one of three distinct values:
+ /// * A non-null sem::Constant pointer. Returned when a expression resolves to a creation time
+ /// value.
+ /// * A null sem::Constant pointer. Returned when a expression cannot resolve to a creation time
+ /// value, but is otherwise legal.
+ /// * `utils::Failure`. Returned when there was a resolver error. In this situation the method
+ /// will have already reported a diagnostic error message, and the caller should abort
+ /// resolving.
+ using ConstantResult = utils::Result<const sem::Constant*>;
+
+ /// Constructor
+ /// @param b the program builder
+ explicit ConstEval(ProgramBuilder& b);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ // Constant value evaluation methods, to be called directly from Resolver
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /// @param ty the target type - must be an array or constructor
+ /// @param args the input arguments
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* ArrayOrStructCtor(const sem::Type* ty,
+ const std::vector<const sem::Expression*>& args);
+
+ /// @param ty the target type
+ /// @param expr the input expression
+ /// @return the bit-cast of the given expression to the given type, or null if the value cannot
+ /// be calculated
+ const sem::Constant* Bitcast(const sem::Type* ty, const sem::Expression* expr);
+
+ /// @param obj the object being indexed
+ /// @param idx the index expression
+ /// @return the result of the index, or null if the value cannot be calculated
+ const sem::Constant* Index(const sem::Expression* obj, const sem::Expression* idx);
+
+ /// @param ty the result type
+ /// @param lit the literal AST node
+ /// @return the constant value of the literal
+ const sem::Constant* Literal(const sem::Type* ty, const ast::LiteralExpression* lit);
+
+ /// @param obj the object being accessed
+ /// @param member the member
+ /// @return the result of the member access, or null if the value cannot be calculated
+ const sem::Constant* MemberAccess(const sem::Expression* obj, const sem::StructMember* member);
+
+ /// @param ty the result type
+ /// @param vector the vector being swizzled
+ /// @param indices the swizzle indices
+ /// @return the result of the swizzle, or null if the value cannot be calculated
+ const sem::Constant* Swizzle(const sem::Type* ty,
+ const sem::Expression* vector,
+ const std::vector<uint32_t>& indices);
+
+ /// Convert the `value` to `target_type`
+ /// @param ty the result type
+ /// @param value the value being converted
+ /// @param source the source location of the conversion
+ /// @return the converted value, or null if the value cannot be calculated
+ ConstantResult Convert(const sem::Type* ty, const sem::Constant* value, const Source& source);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ // Constant value evaluation methods, to be indirectly called via the intrinsic table
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /// Type conversion
+ /// @param ty the result type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments
+ /// @return the converted value, or null if the value cannot be calculated
+ const sem::Constant* Conv(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Zero value type constructor
+ /// @param ty the result type
+ /// @param args the input arguments (no arguments provided)
+ /// @param num_args the number of input arguments (no arguments provided)
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* Zero(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Identity value type constructor
+ /// @param ty the result type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments (must be 1)
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* Identity(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Vector splat constructor
+ /// @param ty the vector type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments (must be 1)
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* VecSplat(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Vector constructor using scalars
+ /// @param ty the vector type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments (must be equal to vector width)
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* VecCtorS(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Vector constructor using a mix of scalars and smaller vectors
+ /// @param ty the vector type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* VecCtorM(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Matrix constructor using scalar values
+ /// @param ty the matrix type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments (must equal num-columns * num-rows)
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* MatCtorS(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ /// Matrix constructor using column vectors
+ /// @param ty the matrix type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments (must equal num-columns)
+ /// @return the constructed value, or null if the value cannot be calculated
+ const sem::Constant* MatCtorV(const sem::Type* ty, ArgumentList args, size_t num_args);
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Operators
+ ////////////////////////////////////////////////////////////////////////////
+
+ /// Complement operator '~'
+ /// @param ty the integer type
+ /// @param args the input arguments
+ /// @param num_args the number of input arguments (must be 1)
+ /// @return the result value, or null if the value cannot be calculated
+ const sem::Constant* OpComplement(const sem::Type* ty,
+ sem::Expression const* const* args,
size_t num_args);
-} // namespace tint::resolver::const_eval
+ private:
+ /// Adds the given error message to the diagnostics
+ void AddError(const std::string& msg, const Source& source) const;
+
+ /// Adds the given warning message to the diagnostics
+ void AddWarning(const std::string& msg, const Source& source) const;
+
+ ProgramBuilder& builder;
+};
+
+} // namespace tint::resolver
#endif // SRC_TINT_RESOLVER_CONST_EVAL_H_
diff --git a/src/tint/resolver/resolver_constants_test.cc b/src/tint/resolver/const_eval_test.cc
similarity index 93%
rename from src/tint/resolver/resolver_constants_test.cc
rename to src/tint/resolver/const_eval_test.cc
index 1774a16..dcc1604 100644
--- a/src/tint/resolver/resolver_constants_test.cc
+++ b/src/tint/resolver/const_eval_test.cc
@@ -12,8 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "src/tint/resolver/resolver.h"
-
#include <cmath>
#include "gtest/gtest.h"
@@ -28,13 +26,13 @@
namespace tint::resolver {
namespace {
-using ResolverConstantsTest = ResolverTest;
+using ResolverConstEvalTest = ResolverTest;
////////////////////////////////////////////////////////////////////////////////////////////////////
// Construction
////////////////////////////////////////////////////////////////////////////////////////////////////
-TEST_F(ResolverConstantsTest, Scalar_i32) {
+TEST_F(ResolverConstEvalTest, Scalar_i32) {
auto* expr = Expr(99_i);
WrapInFunction(expr);
@@ -50,7 +48,7 @@
EXPECT_EQ(sem->ConstantValue()->As<AInt>(), 99);
}
-TEST_F(ResolverConstantsTest, Scalar_u32) {
+TEST_F(ResolverConstEvalTest, Scalar_u32) {
auto* expr = Expr(99_u);
WrapInFunction(expr);
@@ -66,7 +64,7 @@
EXPECT_EQ(sem->ConstantValue()->As<AInt>(), 99u);
}
-TEST_F(ResolverConstantsTest, Scalar_f32) {
+TEST_F(ResolverConstEvalTest, Scalar_f32) {
auto* expr = Expr(9.9_f);
WrapInFunction(expr);
@@ -82,7 +80,7 @@
EXPECT_EQ(sem->ConstantValue()->As<AFloat>().value, 9.9f);
}
-TEST_F(ResolverConstantsTest, Scalar_f16) {
+TEST_F(ResolverConstEvalTest, Scalar_f16) {
Enable(ast::Extension::kF16);
auto* expr = Expr(9.9_h);
@@ -101,7 +99,7 @@
EXPECT_EQ(sem->ConstantValue()->As<AFloat>(), 9.8984375f);
}
-TEST_F(ResolverConstantsTest, Scalar_bool) {
+TEST_F(ResolverConstEvalTest, Scalar_bool) {
auto* expr = Expr(true);
WrapInFunction(expr);
@@ -117,7 +115,7 @@
EXPECT_EQ(sem->ConstantValue()->As<bool>(), true);
}
-TEST_F(ResolverConstantsTest, Vec3_ZeroInit_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_i32) {
auto* expr = vec3<i32>();
WrapInFunction(expr);
@@ -150,7 +148,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 0);
}
-TEST_F(ResolverConstantsTest, Vec3_ZeroInit_u32) {
+TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_u32) {
auto* expr = vec3<u32>();
WrapInFunction(expr);
@@ -183,7 +181,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 0u);
}
-TEST_F(ResolverConstantsTest, Vec3_ZeroInit_f32) {
+TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_f32) {
auto* expr = vec3<f32>();
WrapInFunction(expr);
@@ -216,7 +214,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 0._a);
}
-TEST_F(ResolverConstantsTest, Vec3_ZeroInit_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>();
@@ -251,7 +249,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 0._a);
}
-TEST_F(ResolverConstantsTest, Vec3_ZeroInit_bool) {
+TEST_F(ResolverConstEvalTest, Vec3_ZeroInit_bool) {
auto* expr = vec3<bool>();
WrapInFunction(expr);
@@ -284,7 +282,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), false);
}
-TEST_F(ResolverConstantsTest, Vec3_Splat_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_Splat_i32) {
auto* expr = vec3<i32>(99_i);
WrapInFunction(expr);
@@ -317,7 +315,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 99);
}
-TEST_F(ResolverConstantsTest, Vec3_Splat_u32) {
+TEST_F(ResolverConstEvalTest, Vec3_Splat_u32) {
auto* expr = vec3<u32>(99_u);
WrapInFunction(expr);
@@ -350,7 +348,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 99u);
}
-TEST_F(ResolverConstantsTest, Vec3_Splat_f32) {
+TEST_F(ResolverConstEvalTest, Vec3_Splat_f32) {
auto* expr = vec3<f32>(9.9_f);
WrapInFunction(expr);
@@ -383,7 +381,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 9.9f);
}
-TEST_F(ResolverConstantsTest, Vec3_Splat_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_Splat_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(9.9_h);
@@ -419,7 +417,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 9.8984375f);
}
-TEST_F(ResolverConstantsTest, Vec3_Splat_bool) {
+TEST_F(ResolverConstEvalTest, Vec3_Splat_bool) {
auto* expr = vec3<bool>(true);
WrapInFunction(expr);
@@ -452,7 +450,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), true);
}
-TEST_F(ResolverConstantsTest, Vec3_FullConstruct_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_i32) {
auto* expr = vec3<i32>(1_i, 2_i, 3_i);
WrapInFunction(expr);
@@ -485,7 +483,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
}
-TEST_F(ResolverConstantsTest, Vec3_FullConstruct_u32) {
+TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_u32) {
auto* expr = vec3<u32>(1_u, 2_u, 3_u);
WrapInFunction(expr);
@@ -518,7 +516,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
}
-TEST_F(ResolverConstantsTest, Vec3_FullConstruct_f32) {
+TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_f32) {
auto* expr = vec3<f32>(1_f, 2_f, 3_f);
WrapInFunction(expr);
@@ -551,7 +549,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 3.f);
}
-TEST_F(ResolverConstantsTest, Vec3_FullConstruct_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(1_h, 2_h, 3_h);
@@ -586,7 +584,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 3.f);
}
-TEST_F(ResolverConstantsTest, Vec3_FullConstruct_bool) {
+TEST_F(ResolverConstEvalTest, Vec3_FullConstruct_bool) {
auto* expr = vec3<bool>(true, false, true);
WrapInFunction(expr);
@@ -619,7 +617,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), true);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_i32) {
auto* expr = vec3<i32>(1_i, vec2<i32>(2_i, 3_i));
WrapInFunction(expr);
@@ -652,7 +650,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_u32) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_u32) {
auto* expr = vec3<u32>(vec2<u32>(1_u, 2_u), 3_u);
WrapInFunction(expr);
@@ -685,7 +683,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32) {
auto* expr = vec3<f32>(1_f, vec2<f32>(2_f, 3_f));
WrapInFunction(expr);
@@ -718,7 +716,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 3.f);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32_all_10) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_all_10) {
auto* expr = vec3<f32>(10_f, vec2<f32>(10_f, 10_f));
WrapInFunction(expr);
@@ -751,7 +749,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), 10_f);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32_all_positive_0) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_all_positive_0) {
auto* expr = vec3<f32>(0_f, vec2<f32>(0_f, 0_f));
WrapInFunction(expr);
@@ -784,7 +782,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), 0_f);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32_all_negative_0) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_all_negative_0) {
auto* expr = vec3<f32>(vec2<f32>(-0_f, -0_f), -0_f);
WrapInFunction(expr);
@@ -817,7 +815,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), -0_f);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f32_mixed_sign_0) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f32_mixed_sign_0) {
auto* expr = vec3<f32>(0_f, vec2<f32>(-0_f, 0_f));
WrapInFunction(expr);
@@ -850,7 +848,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), 0_f);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(1_h, vec2<f16>(2_h, 3_h));
@@ -885,7 +883,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 3.f);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f16_all_10) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_all_10) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(10_h, vec2<f16>(10_h, 10_h));
@@ -920,7 +918,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f16>(), 10_h);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f16_all_positive_0) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_all_positive_0) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(0_h, vec2<f16>(0_h, 0_h));
@@ -955,7 +953,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f16>(), 0_h);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f16_all_negative_0) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_all_negative_0) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(vec2<f16>(-0_h, -0_h), -0_h);
@@ -990,7 +988,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f16>(), -0_h);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_f16_mixed_sign_0) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_f16_mixed_sign_0) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(0_h, vec2<f16>(-0_h, 0_h));
@@ -1025,7 +1023,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f16>(), 0_h);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_bool) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_bool) {
auto* expr = vec3<bool>(vec2<bool>(true, false), true);
WrapInFunction(expr);
@@ -1058,7 +1056,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), true);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_all_true) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_all_true) {
auto* expr = vec3<bool>(true, vec2<bool>(true, true));
WrapInFunction(expr);
@@ -1091,7 +1089,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), true);
}
-TEST_F(ResolverConstantsTest, Vec3_MixConstruct_all_false) {
+TEST_F(ResolverConstEvalTest, Vec3_MixConstruct_all_false) {
auto* expr = vec3<bool>(false, vec2<bool>(false, false));
WrapInFunction(expr);
@@ -1124,7 +1122,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<bool>(), false);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_f32_to_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_f32_to_i32) {
auto* expr = vec3<i32>(vec3<f32>(1.1_f, 2.2_f, 3.3_f));
WrapInFunction(expr);
@@ -1157,7 +1155,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_u32_to_f32) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f32) {
auto* expr = vec3<f32>(vec3<u32>(10_u, 20_u, 30_u));
WrapInFunction(expr);
@@ -1190,7 +1188,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 30.f);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_f16_to_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_f16_to_i32) {
Enable(ast::Extension::kF16);
auto* expr = vec3<i32>(vec3<f16>(1.1_h, 2.2_h, 3.3_h));
@@ -1225,7 +1223,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), 3_i);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_u32_to_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_u32_to_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(vec3<u32>(10_u, 20_u, 30_u));
@@ -1260,7 +1258,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), 30.f);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_Large_f32_to_i32) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_i32) {
auto* expr = vec3<i32>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
WrapInFunction(expr);
@@ -1293,7 +1291,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), i32::kHighest);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_Large_f32_to_u32) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_u32) {
auto* expr = vec3<u32>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
WrapInFunction(expr);
@@ -1326,7 +1324,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AInt>(), u32::kHighest);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_Large_f32_to_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Large_f32_to_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(vec3<f32>(1e10_f, -1e20_f, 1e30_f));
@@ -1363,7 +1361,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<AFloat>(), kInf);
}
-TEST_F(ResolverConstantsTest, Vec3_Convert_Small_f32_to_f16) {
+TEST_F(ResolverConstEvalTest, Vec3_Convert_Small_f32_to_f16) {
Enable(ast::Extension::kF16);
auto* expr = vec3<f16>(vec3<f32>(1e-20_f, -2e-30_f, 3e-40_f));
@@ -1401,7 +1399,7 @@
EXPECT_FALSE(std::signbit(sem->ConstantValue()->Index(2)->As<AFloat>().value));
}
-TEST_F(ResolverConstantsTest, Mat2x3_ZeroInit_f32) {
+TEST_F(ResolverConstEvalTest, Mat2x3_ZeroInit_f32) {
auto* expr = mat2x3<f32>();
WrapInFunction(expr);
@@ -1450,7 +1448,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f32>(), 0._f);
}
-TEST_F(ResolverConstantsTest, Mat2x3_ZeroInit_f16) {
+TEST_F(ResolverConstEvalTest, Mat2x3_ZeroInit_f16) {
Enable(ast::Extension::kF16);
auto* expr = mat2x3<f16>();
@@ -1501,7 +1499,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f16>(), 0._h);
}
-TEST_F(ResolverConstantsTest, Mat3x2_Construct_Scalars_af) {
+TEST_F(ResolverConstEvalTest, Mat3x2_Construct_Scalars_af) {
auto* expr = Construct(ty.mat(nullptr, 3, 2), 1.0_a, 2.0_a, 3.0_a, 4.0_a, 5.0_a, 6.0_a);
WrapInFunction(expr);
@@ -1550,7 +1548,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->As<AFloat>(), 6._a);
}
-TEST_F(ResolverConstantsTest, Mat3x2_Construct_Columns_af) {
+TEST_F(ResolverConstEvalTest, Mat3x2_Construct_Columns_af) {
auto* expr = Construct(ty.mat(nullptr, 3, 2), //
vec(nullptr, 2u, 1.0_a, 2.0_a), //
vec(nullptr, 2u, 3.0_a, 4.0_a), //
@@ -1602,7 +1600,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(1)->As<AFloat>(), 6._a);
}
-TEST_F(ResolverConstantsTest, Array_i32_Zero) {
+TEST_F(ResolverConstEvalTest, Array_i32_Zero) {
auto* expr = Construct(ty.array<i32, 4>());
WrapInFunction(expr);
@@ -1640,7 +1638,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(3)->As<i32>(), 0_i);
}
-TEST_F(ResolverConstantsTest, Array_f32_Zero) {
+TEST_F(ResolverConstEvalTest, Array_f32_Zero) {
auto* expr = Construct(ty.array<f32, 4>());
WrapInFunction(expr);
@@ -1678,7 +1676,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(3)->As<f32>(), 0_f);
}
-TEST_F(ResolverConstantsTest, Array_vec3_f32_Zero) {
+TEST_F(ResolverConstEvalTest, Array_vec3_f32_Zero) {
auto* expr = Construct(ty.array(ty.vec3<f32>(), 2_u));
WrapInFunction(expr);
@@ -1726,7 +1724,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f32>(), 0_f);
}
-TEST_F(ResolverConstantsTest, Array_Struct_f32_Zero) {
+TEST_F(ResolverConstEvalTest, Array_Struct_f32_Zero) {
Structure("S", {
Member("m1", ty.f32()),
Member("m2", ty.f32()),
@@ -1768,7 +1766,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->As<f32>(), 0_f);
}
-TEST_F(ResolverConstantsTest, Array_i32_Elements) {
+TEST_F(ResolverConstEvalTest, Array_i32_Elements) {
auto* expr = Construct(ty.array<i32, 4>(), 10_i, 20_i, 30_i, 40_i);
WrapInFunction(expr);
@@ -1806,7 +1804,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(3)->As<i32>(), 40_i);
}
-TEST_F(ResolverConstantsTest, Array_f32_Elements) {
+TEST_F(ResolverConstEvalTest, Array_f32_Elements) {
auto* expr = Construct(ty.array<f32, 4>(), 10_f, 20_f, 30_f, 40_f);
WrapInFunction(expr);
@@ -1844,7 +1842,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(3)->As<f32>(), 40_f);
}
-TEST_F(ResolverConstantsTest, Array_vec3_f32_Elements) {
+TEST_F(ResolverConstEvalTest, Array_vec3_f32_Elements) {
auto* expr = Construct(ty.array(ty.vec3<f32>(), 2_u), //
vec3<f32>(1_f, 2_f, 3_f), vec3<f32>(4_f, 5_f, 6_f));
WrapInFunction(expr);
@@ -1869,7 +1867,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f32>(), 6_f);
}
-TEST_F(ResolverConstantsTest, Array_Struct_f32_Elements) {
+TEST_F(ResolverConstEvalTest, Array_Struct_f32_Elements) {
Structure("S", {
Member("m1", ty.f32()),
Member("m2", ty.f32()),
@@ -1913,7 +1911,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(1)->As<f32>(), 4_f);
}
-TEST_F(ResolverConstantsTest, Struct_I32s_ZeroInit) {
+TEST_F(ResolverConstEvalTest, Struct_I32s_ZeroInit) {
Structure("S", {Member("m1", ty.i32()), Member("m2", ty.i32()), Member("m3", ty.i32())});
auto* expr = Construct(ty.type_name("S"));
WrapInFunction(expr);
@@ -1950,7 +1948,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<i32>(), 0_i);
}
-TEST_F(ResolverConstantsTest, Struct_MixedScalars_ZeroInit) {
+TEST_F(ResolverConstEvalTest, Struct_MixedScalars_ZeroInit) {
Enable(ast::Extension::kF16);
Structure("S", {
@@ -2007,7 +2005,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(4)->As<bool>(), false);
}
-TEST_F(ResolverConstantsTest, Struct_VectorF32s_ZeroInit) {
+TEST_F(ResolverConstEvalTest, Struct_VectorF32s_ZeroInit) {
Structure("S", {
Member("m1", ty.vec3<f32>()),
Member("m2", ty.vec3<f32>()),
@@ -2057,7 +2055,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->Index(2)->As<f32>(), 0._f);
}
-TEST_F(ResolverConstantsTest, Struct_MixedVectors_ZeroInit) {
+TEST_F(ResolverConstEvalTest, Struct_MixedVectors_ZeroInit) {
Enable(ast::Extension::kF16);
Structure("S", {
@@ -2128,7 +2126,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(1)->As<bool>(), false);
}
-TEST_F(ResolverConstantsTest, Struct_Struct_ZeroInit) {
+TEST_F(ResolverConstEvalTest, Struct_Struct_ZeroInit) {
Structure("Inner", {
Member("m1", ty.i32()),
Member("m2", ty.u32()),
@@ -2172,7 +2170,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f32>(), 0_f);
}
-TEST_F(ResolverConstantsTest, Struct_MixedScalars_Construct) {
+TEST_F(ResolverConstEvalTest, Struct_MixedScalars_Construct) {
Enable(ast::Extension::kF16);
Structure("S", {
@@ -2229,7 +2227,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(4)->As<bool>(), false);
}
-TEST_F(ResolverConstantsTest, Struct_MixedVectors_Construct) {
+TEST_F(ResolverConstEvalTest, Struct_MixedVectors_Construct) {
Enable(ast::Extension::kF16);
Structure("S", {
@@ -2301,7 +2299,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(4)->Index(1)->As<bool>(), false);
}
-TEST_F(ResolverConstantsTest, Struct_Struct_Construct) {
+TEST_F(ResolverConstEvalTest, Struct_Struct_Construct) {
Structure("Inner", {
Member("m1", ty.i32()),
Member("m2", ty.u32()),
@@ -2347,7 +2345,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->Index(2)->As<f32>(), 6_f);
}
-TEST_F(ResolverConstantsTest, Struct_Array_Construct) {
+TEST_F(ResolverConstEvalTest, Struct_Array_Construct) {
Structure("S", {
Member("m1", ty.array<i32, 2>()),
Member("m2", ty.array<f32, 3>()),
@@ -2390,7 +2388,7 @@
// Indexing
////////////////////////////////////////////////////////////////////////////////////////////////////
-TEST_F(ResolverConstantsTest, Vec3_Index) {
+TEST_F(ResolverConstEvalTest, Vec3_Index) {
auto* expr = IndexAccessor(vec3<i32>(1_i, 2_i, 3_i), 2_i);
WrapInFunction(expr);
@@ -2406,7 +2404,7 @@
EXPECT_EQ(sem->ConstantValue()->As<i32>(), 3_i);
}
-TEST_F(ResolverConstantsTest, Vec3_Index_OOB_High) {
+TEST_F(ResolverConstEvalTest, Vec3_Index_OOB_High) {
auto* expr = IndexAccessor(vec3<i32>(1_i, 2_i, 3_i), Expr(Source{{12, 34}}, 3_i));
WrapInFunction(expr);
@@ -2423,7 +2421,7 @@
EXPECT_EQ(sem->ConstantValue()->As<i32>(), 3_i);
}
-TEST_F(ResolverConstantsTest, Vec3_Index_OOB_Low) {
+TEST_F(ResolverConstEvalTest, Vec3_Index_OOB_Low) {
auto* expr = IndexAccessor(vec3<i32>(1_i, 2_i, 3_i), Expr(Source{{12, 34}}, -3_i));
WrapInFunction(expr);
@@ -2440,7 +2438,7 @@
EXPECT_EQ(sem->ConstantValue()->As<i32>(), 1_i);
}
-TEST_F(ResolverConstantsTest, Vec3_Swizzle_Scalar) {
+TEST_F(ResolverConstEvalTest, Vec3_Swizzle_Scalar) {
auto* expr = MemberAccessor(vec3<i32>(1_i, 2_i, 3_i), "y");
WrapInFunction(expr);
@@ -2456,7 +2454,7 @@
EXPECT_EQ(sem->ConstantValue()->As<i32>(), 2_i);
}
-TEST_F(ResolverConstantsTest, Vec3_Swizzle_Vector) {
+TEST_F(ResolverConstEvalTest, Vec3_Swizzle_Vector) {
auto* expr = MemberAccessor(vec3<i32>(1_i, 2_i, 3_i), "zx");
WrapInFunction(expr);
@@ -2480,7 +2478,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->As<f32>(), 1._a);
}
-TEST_F(ResolverConstantsTest, Vec3_Swizzle_Chain) {
+TEST_F(ResolverConstEvalTest, Vec3_Swizzle_Chain) {
auto* expr = // (1, 2, 3) -> (2, 3, 1) -> (3, 2) -> 2
MemberAccessor(MemberAccessor(MemberAccessor(vec3<i32>(1_i, 2_i, 3_i), "gbr"), "yx"), "y");
WrapInFunction(expr);
@@ -2497,7 +2495,7 @@
EXPECT_EQ(sem->ConstantValue()->As<i32>(), 2_i);
}
-TEST_F(ResolverConstantsTest, Mat3x2_Index) {
+TEST_F(ResolverConstEvalTest, Mat3x2_Index) {
auto* expr = IndexAccessor(
mat3x2<f32>(vec2<f32>(1._a, 2._a), vec2<f32>(3._a, 4._a), vec2<f32>(5._a, 6._a)), 2_i);
WrapInFunction(expr);
@@ -2522,7 +2520,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->As<f32>(), 6._a);
}
-TEST_F(ResolverConstantsTest, Mat3x2_Index_OOB_High) {
+TEST_F(ResolverConstEvalTest, Mat3x2_Index_OOB_High) {
auto* expr = IndexAccessor(
mat3x2<f32>(vec2<f32>(1._a, 2._a), vec2<f32>(3._a, 4._a), vec2<f32>(5._a, 6._a)),
Expr(Source{{12, 34}}, 3_i));
@@ -2549,7 +2547,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->As<f32>(), 6._a);
}
-TEST_F(ResolverConstantsTest, Mat3x2_Index_OOB_Low) {
+TEST_F(ResolverConstEvalTest, Mat3x2_Index_OOB_Low) {
auto* expr = IndexAccessor(
mat3x2<f32>(vec2<f32>(1._a, 2._a), vec2<f32>(3._a, 4._a), vec2<f32>(5._a, 6._a)),
Expr(Source{{12, 34}}, -3_i));
@@ -2576,7 +2574,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(1)->As<f32>(), 2._a);
}
-TEST_F(ResolverConstantsTest, Array_vec3_f32_Index) {
+TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index) {
auto* expr = IndexAccessor(Construct(ty.array(ty.vec3<f32>(), 2_u), //
vec3<f32>(1_f, 2_f, 3_f), vec3<f32>(4_f, 5_f, 6_f)),
1_i);
@@ -2608,7 +2606,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), 6_f);
}
-TEST_F(ResolverConstantsTest, Array_vec3_f32_Index_OOB_High) {
+TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index_OOB_High) {
auto* expr = IndexAccessor(Construct(ty.array(ty.vec3<f32>(), 2_u), //
vec3<f32>(1_f, 2_f, 3_f), vec3<f32>(4_f, 5_f, 6_f)),
Expr(Source{{12, 34}}, 2_i));
@@ -2641,7 +2639,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), 6_f);
}
-TEST_F(ResolverConstantsTest, Array_vec3_f32_Index_OOB_Low) {
+TEST_F(ResolverConstEvalTest, Array_vec3_f32_Index_OOB_Low) {
auto* expr = IndexAccessor(Construct(ty.array(ty.vec3<f32>(), 2_u), //
vec3<f32>(1_f, 2_f, 3_f), vec3<f32>(4_f, 5_f, 6_f)),
Expr(Source{{12, 34}}, -2_i));
@@ -2677,7 +2675,7 @@
EXPECT_EQ(sem->ConstantValue()->Index(2)->As<f32>(), 3_f);
}
-TEST_F(ResolverConstantsTest, ChainedIndex) {
+TEST_F(ResolverConstEvalTest, ChainedIndex) {
auto* arr_expr = Construct(ty.array(ty.mat2x3<f32>(), 2_u), // array<mat2x3<f32>, 2u>
mat2x3<f32>(vec3<f32>(1_f, 2_f, 3_f), //
vec3<f32>(4_f, 5_f, 6_f)), //
@@ -2773,7 +2771,7 @@
}
}
-TEST_F(ResolverConstantsTest, ChainedIndex_OOB) {
+TEST_F(ResolverConstEvalTest, ChainedIndex_OOB) {
auto* arr_expr = Construct(ty.array(ty.mat2x3<f32>(), 2_u), // array<mat2x3<f32>, 2u>
mat2x3<f32>(vec3<f32>(1_f, 2_f, 3_f), //
vec3<f32>(4_f, 5_f, 6_f)), //
@@ -2876,7 +2874,7 @@
// Member accessing
////////////////////////////////////////////////////////////////////////////////////////////////////
-TEST_F(ResolverConstantsTest, MemberAccess) {
+TEST_F(ResolverConstEvalTest, MemberAccess) {
Structure("Inner", {
Member("i1", ty.i32()),
Member("i2", ty.u32()),
@@ -2926,5 +2924,83 @@
EXPECT_EQ(i2->ConstantValue()->As<u32>(), 2_u);
}
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Unary op
+////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace unary_op {
+
+template <typename T>
+struct Values {
+ T input;
+ T expect;
+};
+
+struct Case {
+ std::variant<Values<AInt>, Values<u32>, Values<i32>> values;
+};
+
+static std::ostream& operator<<(std::ostream& o, const Case& c) {
+ std::visit([&](auto&& v) { o << v.input; }, c.values);
+ return o;
+}
+
+template <typename T>
+Case C(T input, T expect) {
+ return Case{Values<T>{input, expect}};
+}
+
+using ResolverConstEvalUnaryOpTest = ResolverTestWithParam<std::tuple<ast::UnaryOp, Case>>;
+
+TEST_P(ResolverConstEvalUnaryOpTest, Test) {
+ auto op = std::get<0>(GetParam());
+ auto c = std::get<1>(GetParam());
+ std::visit(
+ [&](auto&& values) {
+ using T = decltype(values.expect);
+ auto* expr = create<ast::UnaryOpExpression>(op, Expr(values.input));
+ GlobalConst("C", nullptr, expr);
+
+ EXPECT_TRUE(r()->Resolve()) << r()->error();
+
+ auto* sem = Sem().Get(expr);
+ const sem::Constant* value = sem->ConstantValue();
+ ASSERT_NE(value, nullptr);
+ EXPECT_TYPE(value->Type(), sem->Type());
+ EXPECT_EQ(value->As<T>(), values.expect);
+
+ if constexpr (IsInteger<UnwrapNumber<T>>) {
+ // Check that the constant's integer doesn't contain unexpected data in the MSBs
+ // that are outside of the bit-width of T.
+ EXPECT_EQ(value->As<AInt>(), AInt(values.expect));
+ }
+ },
+ c.values);
+}
+INSTANTIATE_TEST_SUITE_P(Complement,
+ ResolverConstEvalUnaryOpTest,
+ testing::Combine(testing::Values(ast::UnaryOp::kComplement),
+ testing::ValuesIn({
+ // AInt
+ C(0_a, 0xffffffffffffffff_a),
+ C(0xffffffffffffffff_a, 0_a),
+ C(0xf0f0f0f0f0f0f0f0_a, 0x0f0f0f0f0f0f0f0f_a),
+ C(0xaaaaaaaaaaaaaaaa_a, 0x5555555555555555_a),
+ C(0x5555555555555555_a, 0xaaaaaaaaaaaaaaaa_a),
+ // u32
+ C(0_u, 0xffffffff_u),
+ C(0xffffffff_u, 0_u),
+ C(0xf0f0f0f0_u, 0x0f0f0f0f_u),
+ C(0xaaaaaaaa_u, 0x55555555_u),
+ C(0x55555555_u, 0xaaaaaaaa_u),
+ // i32
+ C(0_i, -1_i),
+ C(-1_i, 0_i),
+ C(1_i, -2_i),
+ C(-2_i, 1_i),
+ C(2_i, -3_i),
+ C(-3_i, 2_i),
+ })));
+} // namespace unary_op
+
} // namespace
} // namespace tint::resolver
diff --git a/src/tint/resolver/evaluation_stage_test.cc b/src/tint/resolver/evaluation_stage_test.cc
new file mode 100644
index 0000000..236e4b3
--- /dev/null
+++ b/src/tint/resolver/evaluation_stage_test.cc
@@ -0,0 +1,297 @@
+// Copyright 2022 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.
+
+#include "src/tint/resolver/resolver.h"
+
+#include "gmock/gmock.h"
+#include "src/tint/resolver/resolver_test_helper.h"
+
+using namespace tint::number_suffixes; // NOLINT
+
+namespace tint::resolver {
+namespace {
+
+using ResolverEvaluationStageTest = ResolverTest;
+
+TEST_F(ResolverEvaluationStageTest, Literal_i32) {
+ auto* expr = Expr(123_i);
+ WrapInFunction(expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Literal_f32) {
+ auto* expr = Expr(123_f);
+ WrapInFunction(expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Vector_Ctor) {
+ auto* expr = vec3<f32>();
+ WrapInFunction(expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Vector_Ctor_Const_Const) {
+ // const f = 1.f;
+ // vec2<f32>(f, f);
+ auto* f = Const("f", nullptr, Expr(1_f));
+ auto* expr = vec2<f32>(f, f);
+ WrapInFunction(f, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Vector_Ctor_Runtime_Runtime) {
+ // var f = 1.f;
+ // vec2<f32>(f, f);
+ auto* f = Var("f", nullptr, Expr(1_f));
+ auto* expr = vec2<f32>(f, f);
+ WrapInFunction(f, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, Vector_Conv_Const) {
+ // const f = 1.f;
+ // vec2<u32>(vec2<f32>(f));
+ auto* f = Const("f", nullptr, Expr(1_f));
+ auto* expr = vec2<u32>(vec2<f32>(f));
+ WrapInFunction(f, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Vector_Conv_Runtime) {
+ // var f = 1.f;
+ // vec2<u32>(vec2<f32>(f));
+ auto* f = Var("f", nullptr, Expr(1_f));
+ auto* expr = vec2<u32>(vec2<f32>(f));
+ WrapInFunction(f, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, Matrix_Ctor) {
+ auto* expr = mat2x2<f32>();
+ WrapInFunction(expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Array_Ctor) {
+ auto* expr = array<f32, 3>();
+ WrapInFunction(expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Array_Ctor_Const_Const) {
+ // const f = 1.f;
+ // array<f32, 2>(f, f);
+ auto* f = Const("f", nullptr, Expr(1_f));
+ auto* expr = Construct(ty.array<f32, 2>(), f, f);
+ WrapInFunction(f, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Array_Ctor_Const_Override) {
+ // const f1 = 1.f;
+ // override f2 = 2.f;
+ // array<f32, 2>(f1, f2);
+ auto* f1 = Const("f1", nullptr, Expr(1_f));
+ auto* f2 = Override("f2", nullptr, Expr(2_f));
+ auto* expr = Construct(ty.array<f32, 2>(), f1, f2);
+ WrapInFunction(f1, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f1)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(f2)->Stage(), sem::EvaluationStage::kOverride);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kOverride);
+}
+
+TEST_F(ResolverEvaluationStageTest, Array_Ctor_Override_Runtime) {
+ // override f1 = 1.f;
+ // var f2 = 2.f;
+ // array<f32, 2>(f1, f2);
+ auto* f1 = Override("f1", nullptr, Expr(1_f));
+ auto* f2 = Var("f2", nullptr, Expr(2_f));
+ auto* expr = Construct(ty.array<f32, 2>(), f1, f2);
+ WrapInFunction(f2, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f1)->Stage(), sem::EvaluationStage::kOverride);
+ EXPECT_EQ(Sem().Get(f2)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, Array_Ctor_Const_Runtime) {
+ // const f1 = 1.f;
+ // var f2 = 2.f;
+ // array<f32, 2>(f1, f2);
+ auto* f1 = Const("f1", nullptr, Expr(1_f));
+ auto* f2 = Var("f2", nullptr, Expr(2_f));
+ auto* expr = Construct(ty.array<f32, 2>(), f1, f2);
+ WrapInFunction(f1, f2, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f1)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(f2)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, Array_Ctor_Runtime_Runtime) {
+ // var f = 1.f;
+ // array<f32, 2>(f, f);
+ auto* f = Var("f", nullptr, Expr(1_f));
+ auto* expr = Construct(ty.array<f32, 2>(), f, f);
+ WrapInFunction(f, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(f)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, IndexAccessor_Const_Const) {
+ // const vec = vec4<f32>();
+ // const idx = 1_i;
+ // vec[idx]
+ auto* vec = Const("vec", nullptr, vec4<f32>());
+ auto* idx = Const("idx", nullptr, Expr(1_i));
+ auto* expr = IndexAccessor(vec, idx);
+ WrapInFunction(vec, idx, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(vec)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(idx)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, IndexAccessor_Runtime_Const) {
+ // var vec = vec4<f32>();
+ // const idx = 1_i;
+ // vec[idx]
+ auto* vec = Var("vec", nullptr, vec4<f32>());
+ auto* idx = Const("idx", nullptr, Expr(1_i));
+ auto* expr = IndexAccessor(vec, idx);
+ WrapInFunction(vec, idx, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(vec)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(idx)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, IndexAccessor_Const_Override) {
+ // const vec = vec4<f32>();
+ // override idx = 1_i;
+ // vec[idx]
+ auto* vec = Const("vec", nullptr, vec4<f32>());
+ auto* idx = Override("idx", nullptr, Expr(1_i));
+ auto* expr = IndexAccessor(vec, idx);
+ WrapInFunction(vec, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(vec)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(idx)->Stage(), sem::EvaluationStage::kOverride);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kOverride);
+}
+
+TEST_F(ResolverEvaluationStageTest, IndexAccessor_Const_Runtime) {
+ // const vec = vec4<f32>();
+ // let idx = 1_i;
+ // vec[idx]
+ auto* vec = Const("vec", nullptr, vec4<f32>());
+ auto* idx = Let("idx", nullptr, Expr(1_i));
+ auto* expr = IndexAccessor(vec, idx);
+ WrapInFunction(vec, idx, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(vec)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(idx)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, Swizzle_Const) {
+ // const vec = S();
+ // vec.m
+ auto* vec = Const("vec", nullptr, vec4<f32>());
+ auto* expr = MemberAccessor(vec, "xz");
+ WrapInFunction(vec, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(vec)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, Swizzle_Runtime) {
+ // var vec = S();
+ // vec.m
+ auto* vec = Var("vec", nullptr, vec4<f32>());
+ auto* expr = MemberAccessor(vec, "rg");
+ WrapInFunction(vec, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(vec)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+TEST_F(ResolverEvaluationStageTest, MemberAccessor_Const) {
+ // struct S { m : i32 };
+ // const str = S();
+ // str.m
+ Structure("S", {Member("m", ty.i32())});
+ auto* str = Const("str", nullptr, Construct(ty.type_name("S")));
+ auto* expr = MemberAccessor(str, "m");
+ WrapInFunction(str, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(str)->Stage(), sem::EvaluationStage::kConstant);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kConstant);
+}
+
+TEST_F(ResolverEvaluationStageTest, MemberAccessor_Runtime) {
+ // struct S { m : i32 };
+ // var str = S();
+ // str.m
+ Structure("S", {Member("m", ty.i32())});
+ auto* str = Var("str", nullptr, Construct(ty.type_name("S")));
+ auto* expr = MemberAccessor(str, "m");
+ WrapInFunction(str, expr);
+
+ ASSERT_TRUE(r()->Resolve()) << r()->error();
+ EXPECT_EQ(Sem().Get(str)->Stage(), sem::EvaluationStage::kRuntime);
+ EXPECT_EQ(Sem().Get(expr)->Stage(), sem::EvaluationStage::kRuntime);
+}
+
+} // namespace
+} // namespace tint::resolver
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index d746a6c..730e2cd 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -854,7 +854,7 @@
/// The flags for the overload
OverloadFlags flags;
/// The function used to evaluate the overload at shader-creation time.
- const_eval::Function* const const_eval_fn;
+ ConstEval::Function const const_eval_fn;
};
/// IntrinsicInfo describes a builtin function or operator overload
@@ -928,10 +928,10 @@
const Source& source,
bool is_compound) override;
- const sem::CallTarget* Lookup(CtorConvIntrinsic type,
- const sem::Type* template_arg,
- const std::vector<const sem::Type*>& args,
- const Source& source) override;
+ CtorOrConv Lookup(CtorConvIntrinsic type,
+ const sem::Type* template_arg,
+ const std::vector<const sem::Type*>& args,
+ const Source& source) override;
private:
/// Candidate holds information about an overload evaluated for resolution.
@@ -1119,8 +1119,10 @@
if (match.overload->flags.Contains(OverloadFlag::kSupportsComputePipeline)) {
supported_stages.Add(ast::PipelineStage::kCompute);
}
+ auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
+ : sem::EvaluationStage::kRuntime;
return builder.create<sem::Builtin>(
- builtin_type, match.return_type, std::move(params), supported_stages,
+ builtin_type, match.return_type, std::move(params), eval_stage, supported_stages,
match.overload->flags.Contains(OverloadFlag::kIsDeprecated));
});
return Builtin{sem, match.overload->const_eval_fn};
@@ -1162,7 +1164,11 @@
return {};
}
- return UnaryOperator{match.return_type, match.parameters[0].type};
+ return UnaryOperator{
+ match.return_type,
+ match.parameters[0].type,
+ match.overload->const_eval_fn,
+ };
}
IntrinsicTable::BinaryOperator Impl::Lookup(ast::BinaryOp op,
@@ -1233,13 +1239,18 @@
return {};
}
- return BinaryOperator{match.return_type, match.parameters[0].type, match.parameters[1].type};
+ return BinaryOperator{
+ match.return_type,
+ match.parameters[0].type,
+ match.parameters[1].type,
+ match.overload->const_eval_fn,
+ };
}
-const sem::CallTarget* Impl::Lookup(CtorConvIntrinsic type,
- const sem::Type* template_arg,
- const std::vector<const sem::Type*>& args,
- const Source& source) {
+IntrinsicTable::CtorOrConv Impl::Lookup(CtorConvIntrinsic type,
+ const sem::Type* template_arg,
+ const std::vector<const sem::Type*>& args,
+ const Source& source) {
auto name = str(type);
// Generates an error when no overloads match the provided arguments
@@ -1292,18 +1303,25 @@
nullptr, static_cast<uint32_t>(params.size()), p.type, ast::StorageClass::kNone,
ast::Access::kUndefined, p.usage));
}
- return utils::GetOrCreate(constructors, match, [&]() {
- return builder.create<sem::TypeConstructor>(match.return_type, std::move(params));
+ auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
+ : sem::EvaluationStage::kRuntime;
+ auto* target = utils::GetOrCreate(constructors, match, [&]() {
+ return builder.create<sem::TypeConstructor>(match.return_type, std::move(params),
+ eval_stage);
});
+ return CtorOrConv{target, match.overload->const_eval_fn};
}
// Conversion.
- return utils::GetOrCreate(converters, match, [&]() {
+ auto* target = utils::GetOrCreate(converters, match, [&]() {
auto param = builder.create<sem::Parameter>(
nullptr, 0u, match.parameters[0].type, ast::StorageClass::kNone,
ast::Access::kUndefined, match.parameters[0].usage);
- return builder.create<sem::TypeConversion>(match.return_type, param);
+ auto eval_stage = match.overload->const_eval_fn ? sem::EvaluationStage::kConstant
+ : sem::EvaluationStage::kRuntime;
+ return builder.create<sem::TypeConversion>(match.return_type, param, eval_stage);
});
+ return CtorOrConv{target, match.overload->const_eval_fn};
}
IntrinsicPrototype Impl::MatchIntrinsic(const IntrinsicInfo& intrinsic,
diff --git a/src/tint/resolver/intrinsic_table.h b/src/tint/resolver/intrinsic_table.h
index d10f7bb..79eb82f 100644
--- a/src/tint/resolver/intrinsic_table.h
+++ b/src/tint/resolver/intrinsic_table.h
@@ -47,7 +47,7 @@
/// The semantic info for the builtin
const sem::Builtin* sem = nullptr;
/// The constant evaluation function
- const_eval::Function* const_eval_fn = nullptr;
+ ConstEval::Function const_eval_fn = nullptr;
};
/// UnaryOperator describes a resolved unary operator
@@ -56,6 +56,8 @@
const sem::Type* result = nullptr;
/// The type of the parameter of the unary operator
const sem::Type* parameter = nullptr;
+ /// The constant evaluation function
+ ConstEval::Function const_eval_fn = nullptr;
};
/// BinaryOperator describes a resolved binary operator
@@ -66,6 +68,16 @@
const sem::Type* lhs = nullptr;
/// The type of RHS parameter of the binary operator
const sem::Type* rhs = nullptr;
+ /// The constant evaluation function
+ ConstEval::Function const_eval_fn = nullptr;
+ };
+
+ /// CtorOrConv describes a resolved type constructor or type conversion
+ struct CtorOrConv {
+ /// The result type of the type constructor or type conversion
+ const sem::CallTarget* target = nullptr;
+ /// The constant evaluation function
+ ConstEval::Function const_eval_fn = nullptr;
};
/// Lookup looks for the builtin overload with the given signature, raising an error diagnostic
@@ -109,10 +121,10 @@
/// @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<const sem::Type*>& args,
- const Source& source) = 0;
+ virtual CtorOrConv Lookup(CtorConvIntrinsic type,
+ const sem::Type* template_arg,
+ const std::vector<const sem::Type*>& 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 7869059..80f92ba 100644
--- a/src/tint/resolver/intrinsic_table.inl
+++ b/src/tint/resolver/intrinsic_table.inl
@@ -1715,8 +1715,46 @@
return ss.str();
}
-/// TypeMatcher for 'match scalar'
+/// TypeMatcher for 'match aiu32'
/// @see src/tint/intrinsics.def:134:7
+class Aiu32 : public TypeMatcher {
+ public:
+ /// Checks whether the given type matches the matcher rules, and returns the
+ /// expected, canonicalized type on success.
+ /// Match may define and refine the template 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* Aiu32::Match(MatchState& state, const sem::Type* ty) const {
+ if (match_ai(ty)) {
+ return build_ai(state);
+ }
+ if (match_i32(ty)) {
+ return build_i32(state);
+ }
+ if (match_u32(ty)) {
+ return build_u32(state);
+ }
+ return nullptr;
+}
+
+std::string Aiu32::String(MatchState*) const {
+ std::stringstream ss;
+ // Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
+ // template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
+ ss << Ai().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
+ return ss.str();
+}
+
+/// TypeMatcher for 'match scalar'
+/// @see src/tint/intrinsics.def:135:7
class Scalar : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -1760,7 +1798,7 @@
}
/// TypeMatcher for 'match abstract_or_scalar'
-/// @see src/tint/intrinsics.def:135:7
+/// @see src/tint/intrinsics.def:136:7
class AbstractOrScalar : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -1810,7 +1848,7 @@
}
/// TypeMatcher for 'match af_f32'
-/// @see src/tint/intrinsics.def:136:7
+/// @see src/tint/intrinsics.def:137:7
class AfF32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -1845,7 +1883,7 @@
}
/// TypeMatcher for 'match af_f32f16'
-/// @see src/tint/intrinsics.def:137:7
+/// @see src/tint/intrinsics.def:138:7
class AfF32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -1883,7 +1921,7 @@
}
/// TypeMatcher for 'match scalar_no_f32'
-/// @see src/tint/intrinsics.def:138:7
+/// @see src/tint/intrinsics.def:139:7
class ScalarNoF32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -1924,7 +1962,7 @@
}
/// TypeMatcher for 'match scalar_no_f16'
-/// @see src/tint/intrinsics.def:139:7
+/// @see src/tint/intrinsics.def:140:7
class ScalarNoF16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -1965,7 +2003,7 @@
}
/// TypeMatcher for 'match scalar_no_i32'
-/// @see src/tint/intrinsics.def:140:7
+/// @see src/tint/intrinsics.def:141:7
class ScalarNoI32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -2006,7 +2044,7 @@
}
/// TypeMatcher for 'match scalar_no_u32'
-/// @see src/tint/intrinsics.def:141:7
+/// @see src/tint/intrinsics.def:142:7
class ScalarNoU32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -2047,7 +2085,7 @@
}
/// TypeMatcher for 'match scalar_no_bool'
-/// @see src/tint/intrinsics.def:142:7
+/// @see src/tint/intrinsics.def:143:7
class ScalarNoBool : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
@@ -2088,7 +2126,7 @@
}
/// EnumMatcher for 'match f32_texel_format'
-/// @see src/tint/intrinsics.def:153:7
+/// @see src/tint/intrinsics.def:154:7
class F32TexelFormat : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
@@ -2121,7 +2159,7 @@
}
/// EnumMatcher for 'match i32_texel_format'
-/// @see src/tint/intrinsics.def:155:7
+/// @see src/tint/intrinsics.def:156:7
class I32TexelFormat : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
@@ -2153,7 +2191,7 @@
}
/// EnumMatcher for 'match u32_texel_format'
-/// @see src/tint/intrinsics.def:157:7
+/// @see src/tint/intrinsics.def:158:7
class U32TexelFormat : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
@@ -2185,7 +2223,7 @@
}
/// EnumMatcher for 'match write_only'
-/// @see src/tint/intrinsics.def:160:7
+/// @see src/tint/intrinsics.def:161:7
class WriteOnly : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
@@ -2211,7 +2249,7 @@
}
/// EnumMatcher for 'match function_private_workgroup'
-/// @see src/tint/intrinsics.def:162:7
+/// @see src/tint/intrinsics.def:163:7
class FunctionPrivateWorkgroup : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
@@ -2241,7 +2279,7 @@
}
/// EnumMatcher for 'match workgroup_or_storage'
-/// @see src/tint/intrinsics.def:163:7
+/// @see src/tint/intrinsics.def:164:7
class WorkgroupOrStorage : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
@@ -2404,6 +2442,7 @@
Fiu32 Fiu32_;
Fi32 Fi32_;
Iu32 Iu32_;
+ Aiu32 Aiu32_;
Scalar Scalar_;
AbstractOrScalar AbstractOrScalar_;
AfF32 AfF32_;
@@ -2430,7 +2469,7 @@
~Matchers();
/// The template types, types, and type matchers
- TypeMatcher const* const type[63] = {
+ TypeMatcher const* const type[64] = {
/* [0] */ &template_type_0_,
/* [1] */ &template_type_1_,
/* [2] */ &Bool_,
@@ -2485,15 +2524,16 @@
/* [51] */ &Fiu32_,
/* [52] */ &Fi32_,
/* [53] */ &Iu32_,
- /* [54] */ &Scalar_,
- /* [55] */ &AbstractOrScalar_,
- /* [56] */ &AfF32_,
- /* [57] */ &AfF32F16_,
- /* [58] */ &ScalarNoF32_,
- /* [59] */ &ScalarNoF16_,
- /* [60] */ &ScalarNoI32_,
- /* [61] */ &ScalarNoU32_,
- /* [62] */ &ScalarNoBool_,
+ /* [54] */ &Aiu32_,
+ /* [55] */ &Scalar_,
+ /* [56] */ &AbstractOrScalar_,
+ /* [57] */ &AfF32_,
+ /* [58] */ &AfF32F16_,
+ /* [59] */ &ScalarNoF32_,
+ /* [60] */ &ScalarNoF16_,
+ /* [61] */ &ScalarNoI32_,
+ /* [62] */ &ScalarNoU32_,
+ /* [63] */ &ScalarNoBool_,
};
/// The template numbers, and number matchers
@@ -2557,37 +2597,37 @@
/* [37] */ 43,
/* [38] */ 5,
/* [39] */ 10,
- /* [40] */ 7,
+ /* [40] */ 1,
/* [41] */ 42,
/* [42] */ 5,
/* [43] */ 10,
- /* [44] */ 2,
+ /* [44] */ 7,
/* [45] */ 21,
/* [46] */ 0,
/* [47] */ 2,
/* [48] */ 41,
/* [49] */ 5,
/* [50] */ 10,
- /* [51] */ 1,
- /* [52] */ 40,
- /* [53] */ 5,
- /* [54] */ 10,
- /* [55] */ 6,
- /* [56] */ 43,
- /* [57] */ 4,
- /* [58] */ 10,
- /* [59] */ 5,
- /* [60] */ 42,
- /* [61] */ 0,
- /* [62] */ 1,
+ /* [51] */ 8,
+ /* [52] */ 42,
+ /* [53] */ 0,
+ /* [54] */ 1,
+ /* [55] */ 40,
+ /* [56] */ 5,
+ /* [57] */ 10,
+ /* [58] */ 5,
+ /* [59] */ 43,
+ /* [60] */ 4,
+ /* [61] */ 10,
+ /* [62] */ 0,
/* [63] */ 42,
/* [64] */ 4,
/* [65] */ 10,
- /* [66] */ 8,
+ /* [66] */ 6,
/* [67] */ 41,
/* [68] */ 4,
/* [69] */ 10,
- /* [70] */ 0,
+ /* [70] */ 2,
/* [71] */ 40,
/* [72] */ 4,
/* [73] */ 10,
@@ -2621,84 +2661,84 @@
/* [101] */ 40,
/* [102] */ 3,
/* [103] */ 10,
- /* [104] */ 9,
+ /* [104] */ 17,
/* [105] */ 0,
- /* [106] */ 11,
- /* [107] */ 7,
+ /* [106] */ 9,
+ /* [107] */ 0,
/* [108] */ 9,
- /* [109] */ 7,
+ /* [109] */ 2,
/* [110] */ 9,
- /* [111] */ 2,
- /* [112] */ 9,
- /* [113] */ 1,
- /* [114] */ 46,
- /* [115] */ 0,
- /* [116] */ 11,
- /* [117] */ 1,
+ /* [111] */ 1,
+ /* [112] */ 11,
+ /* [113] */ 7,
+ /* [114] */ 9,
+ /* [115] */ 6,
+ /* [116] */ 9,
+ /* [117] */ 5,
/* [118] */ 9,
- /* [119] */ 6,
- /* [120] */ 11,
- /* [121] */ 8,
- /* [122] */ 9,
- /* [123] */ 5,
- /* [124] */ 9,
- /* [125] */ 8,
- /* [126] */ 28,
- /* [127] */ 0,
+ /* [119] */ 8,
+ /* [120] */ 9,
+ /* [121] */ 7,
+ /* [122] */ 46,
+ /* [123] */ 0,
+ /* [124] */ 28,
+ /* [125] */ 0,
+ /* [126] */ 11,
+ /* [127] */ 1,
/* [128] */ 29,
/* [129] */ 0,
/* [130] */ 30,
/* [131] */ 0,
- /* [132] */ 31,
- /* [133] */ 0,
- /* [134] */ 32,
+ /* [132] */ 11,
+ /* [133] */ 8,
+ /* [134] */ 31,
/* [135] */ 0,
/* [136] */ 11,
/* [137] */ 5,
- /* [138] */ 33,
+ /* [138] */ 32,
/* [139] */ 0,
- /* [140] */ 34,
+ /* [140] */ 33,
/* [141] */ 0,
/* [142] */ 11,
/* [143] */ 6,
- /* [144] */ 11,
- /* [145] */ 2,
- /* [146] */ 12,
- /* [147] */ 0,
+ /* [144] */ 34,
+ /* [145] */ 0,
+ /* [146] */ 11,
+ /* [147] */ 2,
/* [148] */ 12,
- /* [149] */ 7,
+ /* [149] */ 0,
/* [150] */ 12,
- /* [151] */ 8,
- /* [152] */ 13,
- /* [153] */ 0,
- /* [154] */ 20,
- /* [155] */ 7,
+ /* [151] */ 7,
+ /* [152] */ 31,
+ /* [153] */ 7,
+ /* [154] */ 12,
+ /* [155] */ 8,
/* [156] */ 13,
- /* [157] */ 7,
- /* [158] */ 13,
- /* [159] */ 8,
- /* [160] */ 14,
- /* [161] */ 0,
- /* [162] */ 48,
- /* [163] */ 0,
+ /* [157] */ 0,
+ /* [158] */ 48,
+ /* [159] */ 0,
+ /* [160] */ 13,
+ /* [161] */ 7,
+ /* [162] */ 13,
+ /* [163] */ 8,
/* [164] */ 14,
- /* [165] */ 7,
+ /* [165] */ 0,
/* [166] */ 14,
- /* [167] */ 8,
- /* [168] */ 15,
- /* [169] */ 0,
+ /* [167] */ 7,
+ /* [168] */ 14,
+ /* [169] */ 8,
/* [170] */ 15,
- /* [171] */ 7,
+ /* [171] */ 0,
/* [172] */ 15,
- /* [173] */ 8,
- /* [174] */ 16,
- /* [175] */ 0,
+ /* [173] */ 7,
+ /* [174] */ 15,
+ /* [175] */ 8,
/* [176] */ 16,
- /* [177] */ 7,
+ /* [177] */ 0,
/* [178] */ 16,
- /* [179] */ 8,
- /* [180] */ 17,
- /* [181] */ 0,
+ /* [179] */ 7,
+ /* [180] */ 16,
+ /* [181] */ 8,
/* [182] */ 17,
/* [183] */ 7,
/* [184] */ 17,
@@ -2709,33 +2749,33 @@
/* [189] */ 7,
/* [190] */ 18,
/* [191] */ 8,
- /* [192] */ 28,
- /* [193] */ 7,
- /* [194] */ 29,
- /* [195] */ 7,
- /* [196] */ 19,
- /* [197] */ 0,
- /* [198] */ 30,
+ /* [192] */ 19,
+ /* [193] */ 0,
+ /* [194] */ 49,
+ /* [195] */ 0,
+ /* [196] */ 28,
+ /* [197] */ 7,
+ /* [198] */ 29,
/* [199] */ 7,
- /* [200] */ 49,
- /* [201] */ 0,
- /* [202] */ 31,
+ /* [200] */ 30,
+ /* [201] */ 7,
+ /* [202] */ 19,
/* [203] */ 7,
- /* [204] */ 32,
- /* [205] */ 7,
- /* [206] */ 33,
+ /* [204] */ 19,
+ /* [205] */ 8,
+ /* [206] */ 32,
/* [207] */ 7,
- /* [208] */ 19,
+ /* [208] */ 33,
/* [209] */ 7,
- /* [210] */ 19,
- /* [211] */ 8,
+ /* [210] */ 20,
+ /* [211] */ 0,
/* [212] */ 20,
- /* [213] */ 0,
+ /* [213] */ 7,
/* [214] */ 20,
/* [215] */ 8,
/* [216] */ 26,
- /* [217] */ 27,
- /* [218] */ 38,
+ /* [217] */ 38,
+ /* [218] */ 27,
/* [219] */ 37,
/* [220] */ 36,
/* [221] */ 35,
@@ -3080,7 +3120,7 @@
{
/* [65] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [66] */
@@ -3090,7 +3130,7 @@
{
/* [67] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [68] */
@@ -3100,32 +3140,32 @@
{
/* [69] */
/* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [70] */
/* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [71] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [72] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [73] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [74] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [75] */
@@ -3134,73 +3174,73 @@
},
{
/* [76] */
- /* usage */ ParameterUsage::kLevel,
+ /* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[14],
},
{
/* [77] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [78] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[152],
},
{
/* [79] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [80] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [81] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [82] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [83] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [84] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [85] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [86] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [87] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [88] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [89] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [90] */
@@ -3215,7 +3255,7 @@
{
/* [92] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [93] */
@@ -3230,52 +3270,52 @@
{
/* [95] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [96] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* usage */ ParameterUsage::kComponent,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [97] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[130],
},
{
/* [98] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [99] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
+ /* [100] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[38],
},
{
- /* [100] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
/* [101] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [102] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [103] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [104] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [105] */
@@ -3284,13 +3324,13 @@
},
{
/* [106] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [107] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [108] */
@@ -3305,157 +3345,157 @@
{
/* [110] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [111] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [112] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [113] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [114] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [115] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [116] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [117] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [118] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [119] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[58],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [120] */
- /* usage */ ParameterUsage::kComponent,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[208],
},
{
/* [121] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[130],
- },
- {
- /* [122] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
- /* [123] */
+ /* [122] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
- /* [124] */
+ /* [123] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[38],
},
{
+ /* [124] */
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
/* [125] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [126] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [127] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [128] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [129] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [130] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [131] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [132] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [133] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [134] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [135] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [136] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [137] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [138] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [139] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [140] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [141] */
@@ -3464,18 +3504,18 @@
},
{
/* [142] */
- /* usage */ ParameterUsage::kBias,
+ /* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[14],
},
{
/* [143] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [144] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[206],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [145] */
@@ -3485,7 +3525,7 @@
{
/* [146] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [147] */
@@ -3494,18 +3534,18 @@
},
{
/* [148] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kBias,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [149] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [150] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [151] */
@@ -3515,47 +3555,47 @@
{
/* [152] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [153] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [154] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[58],
- },
- {
- /* [155] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
- },
- {
- /* [156] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
- },
- {
- /* [157] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [158] */
/* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[14],
},
{
+ /* [155] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[220],
+ },
+ {
+ /* [156] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
+ },
+ {
+ /* [157] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
+ /* [158] */
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
+ },
+ {
/* [159] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[58],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [160] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [161] */
@@ -3565,7 +3605,7 @@
{
/* [162] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [163] */
@@ -3574,13 +3614,13 @@
},
{
/* [164] */
- /* usage */ ParameterUsage::kBias,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [165] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [166] */
@@ -3590,57 +3630,57 @@
{
/* [167] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [168] */
- /* usage */ ParameterUsage::kBias,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [169] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
- },
- {
- /* [170] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[206],
- },
- {
- /* [171] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
- },
- {
- /* [172] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [173] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[38],
},
{
- /* [174] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[14],
+ /* [169] */
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
- /* [175] */
+ /* [170] */
+ /* usage */ ParameterUsage::kComponent,
+ /* matcher indices */ &kMatcherIndices[38],
+ },
+ {
+ /* [171] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[206],
+ /* matcher indices */ &kMatcherIndices[140],
},
{
- /* [176] */
+ /* [172] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
+ /* [173] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
+ /* [174] */
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
+ },
+ {
+ /* [175] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[217],
+ },
+ {
+ /* [176] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
+ },
+ {
/* [177] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [178] */
@@ -3649,13 +3689,13 @@
},
{
/* [179] */
- /* usage */ ParameterUsage::kBias,
+ /* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[14],
},
{
/* [180] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [181] */
@@ -3665,42 +3705,42 @@
{
/* [182] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [183] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [184] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [185] */
- /* usage */ ParameterUsage::kComponent,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [186] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[138],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [187] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [188] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [189] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [190] */
@@ -3710,12 +3750,12 @@
{
/* [191] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [192] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [193] */
@@ -3724,98 +3764,98 @@
},
{
/* [194] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
- },
- {
- /* [195] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
- },
- {
- /* [196] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
- },
- {
- /* [197] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [198] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
- },
- {
- /* [199] */
/* usage */ ParameterUsage::kDepthRef,
/* matcher indices */ &kMatcherIndices[14],
},
{
- /* [200] */
+ /* [195] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[221],
},
{
+ /* [196] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
+ },
+ {
+ /* [197] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
+ /* [198] */
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [199] */
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
+ },
+ {
+ /* [200] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[152],
+ },
+ {
/* [201] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [202] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [203] */
- /* usage */ ParameterUsage::kDepthRef,
+ /* usage */ ParameterUsage::kBias,
/* matcher indices */ &kMatcherIndices[14],
},
{
/* [204] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [205] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[152],
},
{
/* [206] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [207] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [208] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [209] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [210] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [211] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [212] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [213] */
@@ -3824,133 +3864,133 @@
},
{
/* [214] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [215] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* usage */ ParameterUsage::kComponent,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [216] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[130],
+ },
+ {
+ /* [217] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
- /* [217] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
- },
- {
/* [218] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [219] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [220] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [221] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [222] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [223] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [224] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [225] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [226] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [227] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [228] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kBias,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [229] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [230] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [231] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [232] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [233] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [234] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
- },
- {
- /* [235] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
- },
- {
- /* [236] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
- },
- {
- /* [237] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
- },
- {
- /* [238] */
/* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[38],
},
{
+ /* [234] */
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
+ },
+ {
+ /* [235] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[152],
+ },
+ {
+ /* [236] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
+ },
+ {
+ /* [237] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
+ /* [238] */
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
/* [239] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [240] */
@@ -3960,12 +4000,12 @@
{
/* [241] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [242] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [243] */
@@ -3975,12 +4015,12 @@
{
/* [244] */
/* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [245] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[206],
},
{
/* [246] */
@@ -3990,47 +4030,47 @@
{
/* [247] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [248] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kDdx,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [249] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kDdy,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [250] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
- },
- {
- /* [251] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
- },
- {
- /* [252] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [253] */
- /* usage */ ParameterUsage::kArrayIndex,
+ /* usage */ ParameterUsage::kComponent,
/* matcher indices */ &kMatcherIndices[38],
},
{
+ /* [251] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[128],
+ },
+ {
+ /* [252] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
+ },
+ {
+ /* [253] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
/* [254] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [255] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [256] */
@@ -4040,32 +4080,32 @@
{
/* [257] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [258] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [259] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [260] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [261] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [262] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [263] */
@@ -4074,33 +4114,33 @@
},
{
/* [264] */
- /* usage */ ParameterUsage::kDepthRef,
+ /* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[14],
},
{
/* [265] */
- /* usage */ ParameterUsage::kComponent,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [266] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[130],
- },
- {
- /* [267] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
- /* [268] */
+ /* [267] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
+ /* [268] */
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [269] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [270] */
@@ -4115,7 +4155,7 @@
{
/* [272] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [273] */
@@ -4130,7 +4170,7 @@
{
/* [275] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [276] */
@@ -4140,22 +4180,22 @@
{
/* [277] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [278] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [279] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [280] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
+ /* matcher indices */ &kMatcherIndices[208],
},
{
/* [281] */
@@ -4165,7 +4205,7 @@
{
/* [282] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [283] */
@@ -4174,13 +4214,13 @@
},
{
/* [284] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kBias,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [285] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[204],
+ /* matcher indices */ &kMatcherIndices[208],
},
{
/* [286] */
@@ -4190,47 +4230,47 @@
{
/* [287] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [288] */
- /* usage */ ParameterUsage::kDdx,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [289] */
- /* usage */ ParameterUsage::kDdy,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [290] */
- /* usage */ ParameterUsage::kComponent,
+ /* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[38],
},
{
- /* [291] */
+ /* [289] */
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [290] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[128],
+ /* matcher indices */ &kMatcherIndices[217],
+ },
+ {
+ /* [291] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [292] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [293] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [294] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [295] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[198],
+ /* matcher indices */ &kMatcherIndices[206],
},
{
/* [296] */
@@ -4240,17 +4280,17 @@
{
/* [297] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [298] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [299] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[152],
},
{
/* [300] */
@@ -4260,7 +4300,7 @@
{
/* [301] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [302] */
@@ -4270,67 +4310,67 @@
{
/* [303] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [304] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [305] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [306] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [307] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* matcher indices */ &kMatcherIndices[219],
},
{
/* [308] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [309] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [310] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [311] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
+ /* matcher indices */ &kMatcherIndices[63],
},
{
/* [312] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [313] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [314] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[136],
},
{
/* [315] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [316] */
@@ -4340,17 +4380,17 @@
{
/* [317] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [318] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [319] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [320] */
@@ -4360,17 +4400,17 @@
{
/* [321] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [322] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[58],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [323] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[206],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [324] */
@@ -4380,37 +4420,37 @@
{
/* [325] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [326] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [327] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* matcher indices */ &kMatcherIndices[208],
},
{
/* [328] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [329] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [330] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [331] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
+ /* matcher indices */ &kMatcherIndices[152],
},
{
/* [332] */
@@ -4420,37 +4460,37 @@
{
/* [333] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [334] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [335] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* matcher indices */ &kMatcherIndices[80],
},
{
/* [336] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [337] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [338] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[112],
},
{
/* [339] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [340] */
@@ -4460,7 +4500,7 @@
{
/* [341] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [342] */
@@ -4470,7 +4510,7 @@
{
/* [343] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [344] */
@@ -4480,17 +4520,17 @@
{
/* [345] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [346] */
- /* usage */ ParameterUsage::kOffset,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kBias,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [347] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[200],
},
{
/* [348] */
@@ -4500,7 +4540,7 @@
{
/* [349] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [350] */
@@ -4509,53 +4549,53 @@
},
{
/* [351] */
- /* usage */ ParameterUsage::kComponent,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [352] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[134],
- },
- {
- /* [353] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
- /* [354] */
+ /* [353] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
+ /* [354] */
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [355] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
+ /* matcher indices */ &kMatcherIndices[219],
},
{
/* [356] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [357] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [358] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [359] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
+ /* matcher indices */ &kMatcherIndices[41],
},
{
/* [360] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [361] */
@@ -4564,73 +4604,73 @@
},
{
/* [362] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[142],
},
{
/* [363] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[130],
},
{
/* [364] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [365] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
- },
- {
- /* [366] */
- /* usage */ ParameterUsage::kBias,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [367] */
- /* usage */ ParameterUsage::kComponent,
+ /* usage */ ParameterUsage::kArrayIndex,
/* matcher indices */ &kMatcherIndices[38],
},
{
- /* [368] */
+ /* [366] */
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
+ },
+ {
+ /* [367] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[128],
+ /* matcher indices */ &kMatcherIndices[221],
+ },
+ {
+ /* [368] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [369] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [370] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [371] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[219],
},
{
/* [372] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [373] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [374] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [375] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [376] */
@@ -4640,17 +4680,17 @@
{
/* [377] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [378] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [379] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [380] */
@@ -4660,37 +4700,37 @@
{
/* [381] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [382] */
- /* usage */ ParameterUsage::kBias,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [383] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[204],
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [384] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [385] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kArrayIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [386] */
/* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [387] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[204],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [388] */
@@ -4700,32 +4740,32 @@
{
/* [389] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [390] */
- /* usage */ ParameterUsage::kBias,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kOffset,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [391] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [392] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [393] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [394] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [395] */
@@ -4735,12 +4775,12 @@
{
/* [396] */
/* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [397] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [398] */
@@ -4749,123 +4789,123 @@
},
{
/* [399] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kX,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [400] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kY,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [401] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kZ,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [402] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kW,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [403] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [404] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [405] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [406] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [407] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[219],
},
{
+ /* [404] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
+ },
+ {
+ /* [405] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
+ /* [406] */
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [407] */
+ /* usage */ ParameterUsage::kComponent,
+ /* matcher indices */ &kMatcherIndices[38],
+ },
+ {
/* [408] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[138],
+ },
+ {
+ /* [409] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
- /* [409] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
/* [410] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [411] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [412] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [413] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [414] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [415] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[80],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [416] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [417] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [418] */
- /* usage */ ParameterUsage::kValue,
+ /* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[106],
},
{
/* [419] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[63],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [420] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[218],
},
{
/* [421] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [422] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[136],
+ /* usage */ ParameterUsage::kDepthRef,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [423] */
@@ -4880,12 +4920,12 @@
{
/* [425] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [426] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [427] */
@@ -4900,242 +4940,242 @@
{
/* [429] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [430] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [431] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[41],
+ /* usage */ ParameterUsage::kComponent,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [432] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[128],
},
{
/* [433] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
- },
- {
- /* [434] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[142],
- },
- {
- /* [435] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[130],
- },
- {
- /* [436] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
- },
- {
- /* [437] */
- /* usage */ ParameterUsage::kArrayIndex,
- /* matcher indices */ &kMatcherIndices[38],
- },
- {
- /* [438] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
- },
- {
- /* [439] */
- /* usage */ ParameterUsage::kX,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [440] */
- /* usage */ ParameterUsage::kY,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [441] */
- /* usage */ ParameterUsage::kZ,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [442] */
- /* usage */ ParameterUsage::kW,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [443] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
- },
- {
- /* [444] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[217],
- },
- {
- /* [445] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
- },
- {
- /* [446] */
- /* usage */ ParameterUsage::kDepthRef,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [447] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[140],
- },
- {
- /* [448] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
- },
- {
- /* [449] */
- /* usage */ ParameterUsage::kSampleIndex,
- /* matcher indices */ &kMatcherIndices[38],
- },
- {
- /* [450] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
- },
- {
- /* [451] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
- },
- {
- /* [452] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
- },
- {
- /* [453] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[71],
- },
- {
- /* [454] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[38],
- },
- {
- /* [455] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[136],
- },
- {
- /* [456] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [457] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [458] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [459] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
- },
- {
- /* [460] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
- },
- {
- /* [461] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
- },
- {
- /* [462] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [463] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [464] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [465] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
- },
- {
- /* [466] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
- },
- {
- /* [467] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
- },
- {
- /* [468] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
- },
- {
- /* [469] */
/* usage */ ParameterUsage::kSampler,
/* matcher indices */ &kMatcherIndices[216],
},
{
- /* [470] */
+ /* [434] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
+ },
+ {
+ /* [435] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[206],
+ },
+ {
+ /* [436] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
+ },
+ {
+ /* [437] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
+ /* [438] */
+ /* usage */ ParameterUsage::kBias,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [439] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[152],
+ },
+ {
+ /* [440] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
+ },
+ {
+ /* [441] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
+ /* [442] */
+ /* usage */ ParameterUsage::kBias,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [443] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
+ },
+ {
+ /* [444] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
+ },
+ {
+ /* [445] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
+ },
+ {
+ /* [446] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
+ },
+ {
+ /* [447] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [448] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [449] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [450] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [451] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [452] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [453] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [454] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [455] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [456] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [457] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [458] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [459] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [460] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [461] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [462] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[219],
+ },
+ {
+ /* [463] */
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
+ },
+ {
+ /* [464] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
+ },
+ {
+ /* [465] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[48],
+ },
+ {
+ /* [466] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
+ },
+ {
+ /* [467] */
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[142],
+ },
+ {
+ /* [468] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
+ },
+ {
+ /* [469] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
+ },
+ {
+ /* [470] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[4],
},
{
/* [471] */
- /* usage */ ParameterUsage::kX,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[222],
},
{
/* [472] */
- /* usage */ ParameterUsage::kY,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [473] */
- /* usage */ ParameterUsage::kZw,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [474] */
- /* usage */ ParameterUsage::kX,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [475] */
- /* usage */ ParameterUsage::kYz,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [476] */
- /* usage */ ParameterUsage::kW,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [477] */
@@ -5184,23 +5224,23 @@
},
{
/* [486] */
- /* usage */ ParameterUsage::kXy,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[101],
},
{
/* [487] */
- /* usage */ ParameterUsage::kZ,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [488] */
- /* usage */ ParameterUsage::kW,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[112],
},
{
/* [489] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* matcher indices */ &kMatcherIndices[206],
},
{
/* [490] */
@@ -5210,27 +5250,27 @@
{
/* [491] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [492] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[204],
+ /* matcher indices */ &kMatcherIndices[83],
},
{
/* [493] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [494] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[112],
},
{
/* [495] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[202],
+ /* matcher indices */ &kMatcherIndices[152],
},
{
/* [496] */
@@ -5240,57 +5280,57 @@
{
/* [497] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [498] */
- /* usage */ ParameterUsage::kX,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[74],
},
{
/* [499] */
- /* usage */ ParameterUsage::kY,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [500] */
- /* usage */ ParameterUsage::kZ,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[112],
},
{
/* [501] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[194],
+ /* matcher indices */ &kMatcherIndices[71],
},
{
/* [502] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [503] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[136],
},
{
/* [504] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[192],
+ /* matcher indices */ &kMatcherIndices[67],
},
{
/* [505] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [506] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[136],
},
{
/* [507] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
+ /* matcher indices */ &kMatcherIndices[198],
},
{
/* [508] */
@@ -5300,82 +5340,82 @@
{
/* [509] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [510] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[196],
},
{
/* [511] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [512] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [513] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[59],
},
{
/* [514] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [515] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[136],
},
{
/* [516] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[55],
},
{
/* [517] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [518] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[142],
},
{
/* [519] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[37],
},
{
/* [520] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[57],
},
{
/* [521] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kValue,
+ /* matcher indices */ &kMatcherIndices[142],
},
{
/* [522] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[124],
},
{
/* [523] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [524] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [525] */
@@ -5394,78 +5434,78 @@
},
{
/* [528] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[128],
},
{
/* [529] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [530] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
- },
- {
- /* [531] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
- },
- {
- /* [532] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [533] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [534] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
- },
- {
- /* [535] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
- },
- {
- /* [536] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
- },
- {
- /* [537] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[222],
- },
- {
- /* [538] */
- /* usage */ ParameterUsage::kSampler,
- /* matcher indices */ &kMatcherIndices[216],
- },
- {
- /* [539] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[108],
- },
- {
- /* [540] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[101],
- },
- {
- /* [541] */
- /* usage */ ParameterUsage::kCoords,
+ /* usage */ ParameterUsage::kLevel,
/* matcher indices */ &kMatcherIndices[38],
},
{
+ /* [531] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[134],
+ },
+ {
+ /* [532] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[57],
+ },
+ {
+ /* [533] */
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
+ },
+ {
+ /* [534] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [535] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [536] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [537] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [538] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [539] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [540] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [541] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
/* [542] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[106],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [543] */
@@ -5500,92 +5540,92 @@
{
/* [549] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[83],
+ /* matcher indices */ &kMatcherIndices[144],
},
{
/* [550] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [551] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[106],
+ /* usage */ ParameterUsage::kSampleIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [552] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[74],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [553] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[58],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [554] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[106],
+ /* usage */ ParameterUsage::kLevel,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [555] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[67],
+ /* matcher indices */ &kMatcherIndices[223],
},
{
/* [556] */
/* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* matcher indices */ &kMatcherIndices[116],
},
{
/* [557] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[136],
+ /* usage */ ParameterUsage::kSampleIndex,
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [558] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[56],
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [559] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[58],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [560] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[136],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [561] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[52],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [562] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [563] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[142],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [564] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[48],
+ /* usage */ ParameterUsage::kXy,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [565] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kZ,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [566] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[142],
+ /* usage */ ParameterUsage::kW,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [567] */
@@ -5619,228 +5659,228 @@
},
{
/* [573] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[37],
+ /* usage */ ParameterUsage::kX,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [574] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[58],
+ /* usage */ ParameterUsage::kYz,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [575] */
- /* usage */ ParameterUsage::kValue,
- /* matcher indices */ &kMatcherIndices[142],
+ /* usage */ ParameterUsage::kW,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [576] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[223],
+ /* usage */ ParameterUsage::kX,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [577] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kY,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [578] */
- /* usage */ ParameterUsage::kSampleIndex,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kZw,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [579] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[126],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [580] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [581] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [582] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[128],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [583] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [584] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [585] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[132],
+ /* matcher indices */ &kMatcherIndices[219],
},
{
/* [586] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[58],
+ /* usage */ ParameterUsage::kSampler,
+ /* matcher indices */ &kMatcherIndices[216],
},
{
/* [587] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[43],
},
{
/* [588] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
+ /* usage */ ParameterUsage::kX,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [589] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kY,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [590] */
- /* usage */ ParameterUsage::kLevel,
- /* matcher indices */ &kMatcherIndices[38],
+ /* usage */ ParameterUsage::kZ,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [591] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [592] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [593] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[4],
},
{
/* [594] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[38],
+ /* matcher indices */ &kMatcherIndices[4],
},
{
/* [595] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[77],
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [596] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [597] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [598] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [599] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [600] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [601] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[222],
+ /* usage */ ParameterUsage::kX,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [602] */
- /* usage */ ParameterUsage::kCoords,
- /* matcher indices */ &kMatcherIndices[122],
+ /* usage */ ParameterUsage::kZyw,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [603] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[15],
+ /* usage */ ParameterUsage::kXyz,
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [604] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[19],
+ /* usage */ ParameterUsage::kW,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [605] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* usage */ ParameterUsage::kXy,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [606] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kZw,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [607] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
- },
- {
- /* [608] */
- /* usage */ ParameterUsage::kNone,
+ /* usage */ ParameterUsage::kX,
/* matcher indices */ &kMatcherIndices[1],
},
{
+ /* [608] */
+ /* usage */ ParameterUsage::kYz,
+ /* matcher indices */ &kMatcherIndices[106],
+ },
+ {
/* [609] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* usage */ ParameterUsage::kXy,
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [610] */
- /* usage */ ParameterUsage::kNone,
+ /* usage */ ParameterUsage::kZ,
/* matcher indices */ &kMatcherIndices[1],
},
{
/* [611] */
- /* usage */ ParameterUsage::kNone,
+ /* usage */ ParameterUsage::kX,
/* matcher indices */ &kMatcherIndices[1],
},
{
/* [612] */
- /* usage */ ParameterUsage::kNone,
+ /* usage */ ParameterUsage::kY,
/* matcher indices */ &kMatcherIndices[1],
},
{
/* [613] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [614] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [615] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [616] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[98],
},
{
/* [617] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[126],
+ /* matcher indices */ &kMatcherIndices[124],
},
{
/* [618] */
@@ -5850,12 +5890,12 @@
{
/* [619] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [620] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [621] */
@@ -5875,7 +5915,7 @@
{
/* [624] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[98],
},
{
/* [625] */
@@ -5890,17 +5930,17 @@
{
/* [627] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [628] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [629] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[132],
+ /* matcher indices */ &kMatcherIndices[134],
},
{
/* [630] */
@@ -5910,17 +5950,17 @@
{
/* [631] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [632] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[95],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [633] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[134],
+ /* matcher indices */ &kMatcherIndices[138],
},
{
/* [634] */
@@ -5930,7 +5970,7 @@
{
/* [635] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [636] */
@@ -5940,7 +5980,7 @@
{
/* [637] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[138],
+ /* matcher indices */ &kMatcherIndices[140],
},
{
/* [638] */
@@ -5955,7 +5995,7 @@
{
/* [640] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [641] */
@@ -5965,7 +6005,7 @@
{
/* [642] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [643] */
@@ -5980,12 +6020,12 @@
{
/* [645] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[0],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [646] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [647] */
@@ -6000,12 +6040,12 @@
{
/* [649] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [650] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [651] */
@@ -6025,12 +6065,12 @@
{
/* [654] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [655] */
/* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [656] */
@@ -6045,7 +6085,7 @@
{
/* [658] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [659] */
@@ -6080,12 +6120,12 @@
{
/* [665] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [666] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [667] */
@@ -6100,22 +6140,22 @@
{
/* [669] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[45],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [670] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[45],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [671] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [672] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [673] */
@@ -6130,12 +6170,12 @@
{
/* [675] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [676] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [677] */
@@ -6150,27 +6190,27 @@
{
/* [679] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [680] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [681] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [682] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [683] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [684] */
@@ -6180,27 +6220,27 @@
{
/* [685] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[45],
},
{
/* [686] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[45],
},
{
/* [687] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [688] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [689] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [690] */
@@ -6220,7 +6260,7 @@
{
/* [693] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [694] */
@@ -6230,52 +6270,52 @@
{
/* [695] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [696] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [697] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [698] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [699] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [700] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [701] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [702] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [703] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [704] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [705] */
@@ -6285,97 +6325,97 @@
{
/* [706] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [707] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [708] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [709] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [710] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [711] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[15],
},
{
/* [712] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[19],
},
{
/* [713] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[77],
},
{
/* [714] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [715] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [716] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [717] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [718] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [719] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [720] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [721] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [722] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [723] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [724] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [725] */
@@ -6390,22 +6430,22 @@
{
/* [727] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [728] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [729] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [730] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [731] */
@@ -6415,7 +6455,7 @@
{
/* [732] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [733] */
@@ -6425,66 +6465,66 @@
{
/* [734] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[98],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [735] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [736] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [737] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [738] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[39],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [739] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [740] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [741] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [742] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [743] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [744] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[98],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [745] */
- /* usage */ ParameterUsage::kX,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [746] */
- /* usage */ ParameterUsage::kY,
+ /* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[1],
},
{
@@ -6500,7 +6540,7 @@
{
/* [749] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [750] */
@@ -6509,43 +6549,43 @@
},
{
/* [751] */
- /* usage */ ParameterUsage::kXy,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [752] */
- /* usage */ ParameterUsage::kZ,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [753] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [754] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
- },
- {
- /* [755] */
- /* usage */ ParameterUsage::kX,
/* matcher indices */ &kMatcherIndices[1],
},
{
+ /* [755] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[0],
+ },
+ {
/* [756] */
- /* usage */ ParameterUsage::kYz,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [757] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [758] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [759] */
@@ -6580,27 +6620,27 @@
{
/* [765] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [766] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [767] */
- /* usage */ ParameterUsage::kXy,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [768] */
- /* usage */ ParameterUsage::kZw,
- /* matcher indices */ &kMatcherIndices[104],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [769] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [770] */
@@ -6610,347 +6650,347 @@
{
/* [771] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [772] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [773] */
- /* usage */ ParameterUsage::kXyz,
- /* matcher indices */ &kMatcherIndices[69],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [774] */
- /* usage */ ParameterUsage::kW,
+ /* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[1],
},
{
/* [775] */
- /* usage */ ParameterUsage::kX,
- /* matcher indices */ &kMatcherIndices[1],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[0],
},
{
/* [776] */
- /* usage */ ParameterUsage::kZyw,
- /* matcher indices */ &kMatcherIndices[69],
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [777] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [778] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* matcher indices */ &kMatcherIndices[95],
},
{
/* [779] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [780] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[38],
},
{
/* [781] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [782] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [783] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [784] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
- },
- {
- /* [785] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
- },
- {
- /* [786] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[4],
- },
- {
- /* [787] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
- },
- {
- /* [788] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [789] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [790] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
- },
- {
- /* [791] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
- },
- {
- /* [792] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [793] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [794] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
- },
- {
- /* [795] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [796] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [797] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[223],
- },
- {
- /* [798] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[140],
- },
- {
- /* [799] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
- },
- {
- /* [800] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
- },
- {
- /* [801] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
- },
- {
- /* [802] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
- },
- {
- /* [803] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[138],
- },
- {
- /* [804] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[134],
- },
- {
- /* [805] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[132],
- },
- {
- /* [806] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[130],
- },
- {
- /* [807] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[128],
- },
- {
- /* [808] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[126],
- },
- {
- /* [809] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[60],
- },
- {
- /* [810] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
- },
- {
- /* [811] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
- },
- {
- /* [812] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[138],
- },
- {
- /* [813] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[130],
- },
- {
- /* [814] */
/* usage */ ParameterUsage::kTexture,
/* matcher indices */ &kMatcherIndices[222],
},
{
- /* [815] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[86],
+ /* [784] */
+ /* usage */ ParameterUsage::kCoords,
+ /* matcher indices */ &kMatcherIndices[116],
},
{
- /* [816] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[60],
- },
- {
- /* [817] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[89],
- },
- {
- /* [818] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[92],
- },
- {
- /* [819] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[223],
- },
- {
- /* [820] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[218],
- },
- {
- /* [821] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[219],
- },
- {
- /* [822] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[220],
- },
- {
- /* [823] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[221],
- },
- {
- /* [824] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[140],
- },
- {
- /* [825] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[138],
- },
- {
- /* [826] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[134],
- },
- {
- /* [827] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[132],
- },
- {
- /* [828] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[130],
- },
- {
- /* [829] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[128],
- },
- {
- /* [830] */
- /* usage */ ParameterUsage::kTexture,
- /* matcher indices */ &kMatcherIndices[126],
- },
- {
- /* [831] */
+ /* [785] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[154],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
- /* [832] */
+ /* [786] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[43],
},
{
- /* [833] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
- },
- {
- /* [834] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
- },
- {
- /* [835] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
- },
- {
- /* [836] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
- },
- {
- /* [837] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
- },
- {
- /* [838] */
+ /* [787] */
/* usage */ ParameterUsage::kNone,
/* matcher indices */ &kMatcherIndices[14],
},
{
+ /* [788] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [789] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [790] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [791] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [792] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [793] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [794] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [795] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [796] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[66],
+ },
+ {
+ /* [797] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [798] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [799] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [800] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [801] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [802] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [803] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [804] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [805] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [806] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [807] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [808] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [809] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [810] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [811] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [812] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [813] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [814] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [815] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [816] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [817] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [818] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [819] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [820] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [821] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [822] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [823] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [824] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [825] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [826] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [827] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[27],
+ },
+ {
+ /* [828] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [829] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[14],
+ },
+ {
+ /* [830] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
+ /* [831] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [832] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [833] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [834] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [835] */
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[217],
+ },
+ {
+ /* [836] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[31],
+ },
+ {
+ /* [837] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[1],
+ },
+ {
+ /* [838] */
+ /* usage */ ParameterUsage::kNone,
+ /* matcher indices */ &kMatcherIndices[34],
+ },
+ {
/* [839] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[11],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [840] */
@@ -6975,12 +7015,12 @@
{
/* [844] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [845] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [846] */
@@ -7025,22 +7065,22 @@
{
/* [854] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [855] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [856] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [857] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [858] */
@@ -7075,112 +7115,112 @@
{
/* [864] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [865] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [866] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[120],
},
{
/* [867] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[106],
+ /* matcher indices */ &kMatcherIndices[112],
},
{
/* [868] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[106],
+ /* matcher indices */ &kMatcherIndices[112],
},
{
/* [869] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[223],
},
{
/* [870] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[144],
},
{
/* [871] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[108],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [872] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[219],
},
{
/* [873] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [874] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [875] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[140],
},
{
/* [876] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[138],
},
{
/* [877] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[134],
},
{
/* [878] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[130],
},
{
/* [879] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[128],
},
{
/* [880] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[124],
},
{
/* [881] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[52],
},
{
/* [882] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[217],
},
{
/* [883] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [884] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[140],
},
{
/* [885] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[130],
},
{
/* [886] */
@@ -7190,62 +7230,62 @@
{
/* [887] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [888] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [889] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [890] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [891] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [892] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [893] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [894] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [895] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [896] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [897] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [898] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [899] */
@@ -7259,93 +7299,93 @@
},
{
/* [901] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[222],
},
{
/* [902] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[86],
},
{
/* [903] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[52],
},
{
/* [904] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[89],
},
{
/* [905] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[92],
},
{
/* [906] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[214],
},
{
/* [907] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[223],
},
{
/* [908] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[212],
},
{
/* [909] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[219],
},
{
/* [910] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[220],
},
{
/* [911] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[221],
},
{
/* [912] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[144],
},
{
/* [913] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[214],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[140],
},
{
/* [914] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[184],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[138],
},
{
/* [915] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[27],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[134],
},
{
/* [916] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[130],
},
{
/* [917] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[128],
},
{
/* [918] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* usage */ ParameterUsage::kTexture,
+ /* matcher indices */ &kMatcherIndices[124],
},
{
/* [919] */
@@ -7365,12 +7405,12 @@
{
/* [922] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[210],
},
{
/* [923] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[55],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [924] */
@@ -7380,7 +7420,7 @@
{
/* [925] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[212],
+ /* matcher indices */ &kMatcherIndices[204],
},
{
/* [926] */
@@ -7395,12 +7435,12 @@
{
/* [928] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[210],
+ /* matcher indices */ &kMatcherIndices[202],
},
{
/* [929] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[66],
+ /* matcher indices */ &kMatcherIndices[51],
},
{
/* [930] */
@@ -7410,7 +7450,7 @@
{
/* [931] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[208],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [932] */
@@ -7425,12 +7465,12 @@
{
/* [934] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [935] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[104],
+ /* matcher indices */ &kMatcherIndices[106],
},
{
/* [936] */
@@ -7440,42 +7480,42 @@
{
/* [937] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [938] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[112],
+ /* matcher indices */ &kMatcherIndices[110],
},
{
/* [939] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[112],
+ /* matcher indices */ &kMatcherIndices[110],
},
{
/* [940] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[112],
+ /* matcher indices */ &kMatcherIndices[110],
},
{
/* [941] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[112],
+ /* matcher indices */ &kMatcherIndices[110],
},
{
/* [942] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[112],
+ /* matcher indices */ &kMatcherIndices[110],
},
{
/* [943] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[192],
},
{
/* [944] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[69],
+ /* matcher indices */ &kMatcherIndices[61],
},
{
/* [945] */
@@ -7485,47 +7525,47 @@
{
/* [946] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [947] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [948] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[31],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [949] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[50],
+ /* matcher indices */ &kMatcherIndices[39],
},
{
/* [950] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[50],
+ /* matcher indices */ &kMatcherIndices[39],
},
{
/* [951] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[50],
+ /* matcher indices */ &kMatcherIndices[39],
},
{
/* [952] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[50],
+ /* matcher indices */ &kMatcherIndices[39],
},
{
/* [953] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[50],
+ /* matcher indices */ &kMatcherIndices[39],
},
{
/* [954] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[190],
},
{
/* [955] */
@@ -7540,7 +7580,7 @@
{
/* [957] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [958] */
@@ -7555,152 +7595,152 @@
{
/* [960] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[6],
},
{
/* [961] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [962] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[66],
},
{
/* [963] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [964] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[116],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [965] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[116],
+ /* matcher indices */ &kMatcherIndices[126],
},
{
/* [966] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[116],
+ /* matcher indices */ &kMatcherIndices[126],
},
{
/* [967] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[116],
+ /* matcher indices */ &kMatcherIndices[126],
},
{
/* [968] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[116],
+ /* matcher indices */ &kMatcherIndices[126],
},
{
/* [969] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[196],
+ /* matcher indices */ &kMatcherIndices[188],
},
{
/* [970] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[146],
+ /* matcher indices */ &kMatcherIndices[148],
},
{
/* [971] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[45],
},
{
/* [972] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[11],
},
{
/* [973] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[150],
},
{
/* [974] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[148],
+ /* matcher indices */ &kMatcherIndices[154],
},
{
/* [975] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[150],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [976] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[190],
+ /* matcher indices */ &kMatcherIndices[156],
},
{
/* [977] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[152],
+ /* matcher indices */ &kMatcherIndices[45],
},
{
/* [978] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [979] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[160],
},
{
/* [980] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[162],
},
{
/* [981] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[156],
+ /* matcher indices */ &kMatcherIndices[17],
},
{
/* [982] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[158],
+ /* matcher indices */ &kMatcherIndices[164],
},
{
/* [983] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[188],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [984] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[160],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [985] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[166],
},
{
/* [986] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[168],
},
{
/* [987] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[186],
},
{
/* [988] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[164],
+ /* matcher indices */ &kMatcherIndices[170],
},
{
/* [989] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[166],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [990] */
@@ -7710,112 +7750,67 @@
{
/* [991] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[168],
+ /* matcher indices */ &kMatcherIndices[172],
},
{
/* [992] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[174],
},
{
/* [993] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[184],
},
{
/* [994] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
+ /* matcher indices */ &kMatcherIndices[176],
},
{
/* [995] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[170],
+ /* matcher indices */ &kMatcherIndices[14],
},
{
/* [996] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[172],
+ /* matcher indices */ &kMatcherIndices[31],
},
{
/* [997] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
+ /* matcher indices */ &kMatcherIndices[178],
},
{
/* [998] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[174],
+ /* matcher indices */ &kMatcherIndices[180],
},
{
/* [999] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
+ /* matcher indices */ &kMatcherIndices[182],
},
{
/* [1000] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[6],
+ /* matcher indices */ &kMatcherIndices[104],
},
{
/* [1001] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[45],
+ /* matcher indices */ &kMatcherIndices[34],
},
{
/* [1002] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[176],
+ /* matcher indices */ &kMatcherIndices[1],
},
{
/* [1003] */
/* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[178],
- },
- {
- /* [1004] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [1005] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[180],
- },
- {
- /* [1006] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[1],
- },
- {
- /* [1007] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[17],
- },
- {
- /* [1008] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[45],
- },
- {
- /* [1009] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[182],
- },
- {
- /* [1010] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[14],
- },
- {
- /* [1011] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[186],
- },
- {
- /* [1012] */
- /* usage */ ParameterUsage::kNone,
- /* matcher indices */ &kMatcherIndices[34],
+ /* matcher indices */ &kMatcherIndices[126],
},
};
@@ -7828,7 +7823,7 @@
{
/* [1] */
/* name */ "U",
- /* matcher index */ 62,
+ /* matcher index */ 63,
},
{
/* [2] */
@@ -7838,7 +7833,7 @@
{
/* [3] */
/* name */ "U",
- /* matcher index */ 58,
+ /* matcher index */ 59,
},
{
/* [4] */
@@ -7848,22 +7843,22 @@
{
/* [5] */
/* name */ "U",
- /* matcher index */ 59,
+ /* matcher index */ 60,
},
{
/* [6] */
/* name */ "T",
- /* matcher index */ 5,
+ /* matcher index */ 6,
},
{
/* [7] */
/* name */ "U",
- /* matcher index */ 60,
+ /* matcher index */ 62,
},
{
/* [8] */
/* name */ "T",
- /* matcher index */ 6,
+ /* matcher index */ 5,
},
{
/* [9] */
@@ -7878,52 +7873,52 @@
{
/* [11] */
/* name */ "T",
- /* matcher index */ 57,
+ /* matcher index */ 58,
},
{
/* [12] */
/* name */ "T",
- /* matcher index */ 56,
+ /* matcher index */ 50,
},
{
/* [13] */
/* name */ "T",
- /* matcher index */ 50,
+ /* matcher index */ 51,
},
{
/* [14] */
/* name */ "T",
- /* matcher index */ 51,
+ /* matcher index */ 56,
},
{
/* [15] */
/* name */ "T",
- /* matcher index */ 55,
+ /* matcher index */ kNoMatcher,
},
{
/* [16] */
/* name */ "T",
- /* matcher index */ 54,
+ /* matcher index */ 55,
},
{
/* [17] */
/* name */ "T",
- /* matcher index */ kNoMatcher,
+ /* matcher index */ 63,
},
{
/* [18] */
/* name */ "T",
- /* matcher index */ 59,
+ /* matcher index */ 60,
},
{
/* [19] */
/* name */ "T",
- /* matcher index */ 62,
+ /* matcher index */ 59,
},
{
/* [20] */
/* name */ "T",
- /* matcher index */ 58,
+ /* matcher index */ 62,
},
{
/* [21] */
@@ -7933,12 +7928,12 @@
{
/* [22] */
/* name */ "T",
- /* matcher index */ 60,
+ /* matcher index */ 52,
},
{
/* [23] */
/* name */ "T",
- /* matcher index */ 52,
+ /* matcher index */ 54,
},
};
@@ -8001,9 +7996,9 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[830],
+ /* parameters */ &kParameters[918],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8013,7 +8008,7 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[617],
/* return matcher indices */ &kMatcherIndices[38],
@@ -8025,10 +8020,10 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[829],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[917],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8037,10 +8032,10 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[621],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8049,10 +8044,10 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[828],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[916],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8061,10 +8056,10 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[625],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8073,10 +8068,10 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[827],
- /* return matcher indices */ &kMatcherIndices[58],
+ /* parameters */ &kParameters[915],
+ /* return matcher indices */ &kMatcherIndices[57],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8085,10 +8080,10 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[629],
- /* return matcher indices */ &kMatcherIndices[58],
+ /* return matcher indices */ &kMatcherIndices[57],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8097,10 +8092,10 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[826],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[914],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8109,10 +8104,10 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[633],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8121,10 +8116,10 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[825],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[913],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8133,10 +8128,10 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[637],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8145,10 +8140,10 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[824],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[912],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8159,8 +8154,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[823],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[911],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8172,7 +8167,7 @@
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[643],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8183,8 +8178,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[822],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[910],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8196,7 +8191,7 @@
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[647],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8207,8 +8202,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[821],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[909],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8220,7 +8215,7 @@
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[651],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8231,8 +8226,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[820],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[835],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8244,7 +8239,7 @@
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[655],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8255,8 +8250,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[819],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[907],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8267,7 +8262,7 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[3],
- /* parameters */ &kParameters[818],
+ /* parameters */ &kParameters[905],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8279,8 +8274,8 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[3],
- /* parameters */ &kParameters[817],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[904],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8291,8 +8286,8 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[3],
- /* parameters */ &kParameters[816],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[903],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8303,8 +8298,8 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[3],
- /* parameters */ &kParameters[815],
- /* return matcher indices */ &kMatcherIndices[58],
+ /* parameters */ &kParameters[902],
+ /* return matcher indices */ &kMatcherIndices[57],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8315,8 +8310,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[814],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* parameters */ &kParameters[901],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8327,10 +8322,10 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[16],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
+ /* parameters */ &kParameters[1004],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
/* [28] */
@@ -8342,103 +8337,103 @@
/* parameters */ &kParameters[955],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
/* [29] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[956],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecSplat,
},
{
/* [30] */
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[439],
+ /* parameters */ &kParameters[399],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorS,
},
{
/* [31] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[486],
+ /* parameters */ &kParameters[564],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [32] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[474],
+ /* parameters */ &kParameters[573],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [33] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[471],
+ /* parameters */ &kParameters[576],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [34] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[767],
+ /* parameters */ &kParameters[605],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [35] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[773],
+ /* parameters */ &kParameters[603],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [36] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[775],
+ /* parameters */ &kParameters[601],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [37] */
@@ -8447,10 +8442,10 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[2],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[964],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[1003],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [38] */
@@ -8460,33 +8455,33 @@
/* template types */ &kTemplateTypes[4],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[965],
- /* return matcher indices */ &kMatcherIndices[120],
+ /* return matcher indices */ &kMatcherIndices[132],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [39] */
/* num parameters */ 1,
/* num template types */ 2,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[6],
+ /* template types */ &kTemplateTypes[8],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[966],
/* return matcher indices */ &kMatcherIndices[136],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [40] */
/* num parameters */ 1,
/* num template types */ 2,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[8],
+ /* template types */ &kTemplateTypes[6],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[967],
/* return matcher indices */ &kMatcherIndices[142],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [41] */
@@ -8496,9 +8491,9 @@
/* template types */ &kTemplateTypes[0],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[968],
- /* return matcher indices */ &kMatcherIndices[144],
+ /* return matcher indices */ &kMatcherIndices[146],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [42] */
@@ -8507,8 +8502,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[504],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[510],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8519,8 +8514,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[501],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[507],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8531,8 +8526,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[315],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[351],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8543,8 +8538,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[295],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[347],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8555,8 +8550,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[210],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[230],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8568,7 +8563,7 @@
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[495],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8579,8 +8574,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[319],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[331],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8591,8 +8586,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[492],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[489],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8603,8 +8598,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[323],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[327],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -8615,7 +8610,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[489],
+ /* parameters */ &kParameters[474],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
@@ -8627,7 +8622,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[335],
+ /* parameters */ &kParameters[323],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
@@ -8639,7 +8634,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[347],
+ /* parameters */ &kParameters[319],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
@@ -8651,7 +8646,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[180],
+ /* parameters */ &kParameters[165],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
@@ -8663,7 +8658,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[468],
+ /* parameters */ &kParameters[462],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
@@ -8675,7 +8670,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[355],
+ /* parameters */ &kParameters[339],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
@@ -8687,8 +8682,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[299],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[315],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8699,8 +8694,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[220],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[265],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8711,8 +8706,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[245],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[260],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8723,8 +8718,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[72],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[132],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8735,8 +8730,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[375],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[299],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8747,8 +8742,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[150],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[205],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8759,8 +8754,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[383],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[295],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8771,8 +8766,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[170],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[285],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8783,7 +8778,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[391],
+ /* parameters */ &kParameters[303],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8795,7 +8790,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[215],
+ /* parameters */ &kParameters[275],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8831,7 +8826,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[407],
+ /* parameters */ &kParameters[307],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8843,7 +8838,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[280],
+ /* parameters */ &kParameters[255],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8855,8 +8850,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[537],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[471],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8865,9 +8860,9 @@
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[367],
+ /* parameters */ &kParameters[431],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8877,9 +8872,9 @@
/* num parameters */ 5,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[290],
+ /* parameters */ &kParameters[250],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8889,9 +8884,9 @@
/* num parameters */ 5,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[265],
+ /* parameters */ &kParameters[215],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8901,9 +8896,9 @@
/* num parameters */ 6,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[120],
+ /* parameters */ &kParameters[96],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8913,9 +8908,9 @@
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[351],
+ /* parameters */ &kParameters[407],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8925,9 +8920,9 @@
/* num parameters */ 5,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[185],
+ /* parameters */ &kParameters[170],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -8939,8 +8934,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[534],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[558],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8951,8 +8946,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[343],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[387],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8963,8 +8958,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[339],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[379],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8975,8 +8970,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[190],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[160],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8987,8 +8982,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[507],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[585],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -8999,8 +8994,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[331],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[375],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9011,7 +9006,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[540],
+ /* parameters */ &kParameters[486],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9023,7 +9018,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[549],
+ /* parameters */ &kParameters[492],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9035,7 +9030,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[415],
+ /* parameters */ &kParameters[335],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9047,7 +9042,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[552],
+ /* parameters */ &kParameters[498],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9059,7 +9054,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[453],
+ /* parameters */ &kParameters[501],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9071,7 +9066,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[555],
+ /* parameters */ &kParameters[504],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9083,7 +9078,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[419],
+ /* parameters */ &kParameters[311],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9095,7 +9090,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[558],
+ /* parameters */ &kParameters[513],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9107,7 +9102,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[561],
+ /* parameters */ &kParameters[516],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9119,7 +9114,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[564],
+ /* parameters */ &kParameters[465],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9131,7 +9126,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[431],
+ /* parameters */ &kParameters[359],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9143,7 +9138,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[573],
+ /* parameters */ &kParameters[519],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9155,10 +9150,10 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[16],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[69],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[61],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
/* [97] */
@@ -9168,57 +9163,57 @@
/* template types */ &kTemplateTypes[16],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[944],
- /* return matcher indices */ &kMatcherIndices[69],
+ /* return matcher indices */ &kMatcherIndices[61],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
/* [98] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[945],
- /* return matcher indices */ &kMatcherIndices[69],
+ /* return matcher indices */ &kMatcherIndices[61],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecSplat,
},
{
/* [99] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[498],
- /* return matcher indices */ &kMatcherIndices[69],
+ /* parameters */ &kParameters[588],
+ /* return matcher indices */ &kMatcherIndices[61],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorS,
},
{
/* [100] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[751],
- /* return matcher indices */ &kMatcherIndices[69],
+ /* parameters */ &kParameters[609],
+ /* return matcher indices */ &kMatcherIndices[61],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [101] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[755],
- /* return matcher indices */ &kMatcherIndices[69],
+ /* parameters */ &kParameters[607],
+ /* return matcher indices */ &kMatcherIndices[61],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorM,
},
{
/* [102] */
@@ -9228,9 +9223,9 @@
/* template types */ &kTemplateTypes[2],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[949],
- /* return matcher indices */ &kMatcherIndices[39],
+ /* return matcher indices */ &kMatcherIndices[43],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [103] */
@@ -9240,33 +9235,33 @@
/* template types */ &kTemplateTypes[4],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[950],
- /* return matcher indices */ &kMatcherIndices[65],
+ /* return matcher indices */ &kMatcherIndices[50],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [104] */
/* num parameters */ 1,
/* num template types */ 2,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[6],
+ /* template types */ &kTemplateTypes[8],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[951],
- /* return matcher indices */ &kMatcherIndices[58],
+ /* return matcher indices */ &kMatcherIndices[57],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [105] */
/* num parameters */ 1,
/* num template types */ 2,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[8],
+ /* template types */ &kTemplateTypes[6],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[952],
- /* return matcher indices */ &kMatcherIndices[54],
+ /* return matcher indices */ &kMatcherIndices[65],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [106] */
@@ -9276,18 +9271,18 @@
/* template types */ &kTemplateTypes[0],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[953],
- /* return matcher indices */ &kMatcherIndices[43],
+ /* return matcher indices */ &kMatcherIndices[69],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [107] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[808],
+ /* parameters */ &kParameters[880],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9297,9 +9292,9 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[807],
+ /* parameters */ &kParameters[879],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9309,9 +9304,9 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[806],
+ /* parameters */ &kParameters[878],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9321,9 +9316,9 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[805],
+ /* parameters */ &kParameters[877],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9333,9 +9328,9 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[804],
+ /* parameters */ &kParameters[876],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9345,9 +9340,9 @@
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[803],
+ /* parameters */ &kParameters[875],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9359,7 +9354,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[802],
+ /* parameters */ &kParameters[874],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9371,7 +9366,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[801],
+ /* parameters */ &kParameters[873],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9383,7 +9378,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[800],
+ /* parameters */ &kParameters[872],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9395,7 +9390,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[799],
+ /* parameters */ &kParameters[871],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9405,9 +9400,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[759],
+ /* parameters */ &kParameters[727],
/* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9417,9 +9412,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[771],
+ /* parameters */ &kParameters[725],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9429,9 +9424,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[787],
+ /* parameters */ &kParameters[723],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9441,9 +9436,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[789],
+ /* parameters */ &kParameters[721],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9455,7 +9450,7 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[793],
+ /* parameters */ &kParameters[719],
/* return matcher indices */ &kMatcherIndices[11],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9467,7 +9462,7 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[791],
+ /* parameters */ &kParameters[717],
/* return matcher indices */ &kMatcherIndices[11],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9479,7 +9474,7 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[1],
- /* parameters */ &kParameters[591],
+ /* parameters */ &kParameters[715],
/* return matcher indices */ &kMatcherIndices[77],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9491,7 +9486,7 @@
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[1],
- /* parameters */ &kParameters[595],
+ /* parameters */ &kParameters[713],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9503,7 +9498,7 @@
/* num template numbers */ 3,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[0],
- /* parameters */ &kParameters[603],
+ /* parameters */ &kParameters[711],
/* return matcher indices */ &kMatcherIndices[23],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9513,9 +9508,9 @@
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[579],
+ /* parameters */ &kParameters[522],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9525,9 +9520,9 @@
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[582],
+ /* parameters */ &kParameters[528],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9537,9 +9532,9 @@
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[435],
+ /* parameters */ &kParameters[363],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9549,9 +9544,9 @@
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[585],
+ /* parameters */ &kParameters[531],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9561,9 +9556,9 @@
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[447],
+ /* parameters */ &kParameters[549],
/* return matcher indices */ &kMatcherIndices[4],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9575,7 +9570,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[588],
+ /* parameters */ &kParameters[552],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9587,7 +9582,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[359],
+ /* parameters */ &kParameters[383],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9599,7 +9594,7 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[576],
+ /* parameters */ &kParameters[555],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -9611,8 +9606,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[601],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[783],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9623,10 +9618,10 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[16],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[104],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[106],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
/* [136] */
@@ -9636,33 +9631,33 @@
/* template types */ &kTemplateTypes[16],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[935],
- /* return matcher indices */ &kMatcherIndices[104],
+ /* return matcher indices */ &kMatcherIndices[106],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
/* [137] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[936],
- /* return matcher indices */ &kMatcherIndices[104],
+ /* return matcher indices */ &kMatcherIndices[106],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecSplat,
},
{
/* [138] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[15],
+ /* template types */ &kTemplateTypes[14],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[745],
- /* return matcher indices */ &kMatcherIndices[104],
+ /* parameters */ &kParameters[611],
+ /* return matcher indices */ &kMatcherIndices[106],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::VecCtorS,
},
{
/* [139] */
@@ -9672,9 +9667,9 @@
/* template types */ &kTemplateTypes[2],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[938],
- /* return matcher indices */ &kMatcherIndices[108],
+ /* return matcher indices */ &kMatcherIndices[120],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [140] */
@@ -9684,33 +9679,33 @@
/* template types */ &kTemplateTypes[4],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[939],
- /* return matcher indices */ &kMatcherIndices[124],
+ /* return matcher indices */ &kMatcherIndices[118],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [141] */
/* num parameters */ 1,
/* num template types */ 2,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[6],
+ /* template types */ &kTemplateTypes[8],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[940],
- /* return matcher indices */ &kMatcherIndices[122],
+ /* return matcher indices */ &kMatcherIndices[116],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [142] */
/* num parameters */ 1,
/* num template types */ 2,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[8],
+ /* template types */ &kTemplateTypes[6],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[941],
- /* return matcher indices */ &kMatcherIndices[118],
+ /* return matcher indices */ &kMatcherIndices[114],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [143] */
@@ -9720,9 +9715,9 @@
/* template types */ &kTemplateTypes[0],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[942],
- /* return matcher indices */ &kMatcherIndices[110],
+ /* return matcher indices */ &kMatcherIndices[108],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [144] */
@@ -9731,8 +9726,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[255],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[180],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9743,8 +9738,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[84],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[108],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9755,8 +9750,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[108],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[102],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9768,7 +9763,7 @@
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[65],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9779,8 +9774,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[275],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[235],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9791,8 +9786,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[114],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[78],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9803,8 +9798,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[285],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[245],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9815,8 +9810,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[144],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[120],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -9827,8 +9822,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[363],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[343],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9839,8 +9834,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[165],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[225],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9851,8 +9846,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[160],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[150],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9863,8 +9858,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[138],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[144],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9875,8 +9870,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[379],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[439],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9887,8 +9882,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[155],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[200],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9899,8 +9894,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[387],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[435],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9911,8 +9906,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[175],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[280],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
@@ -9921,771 +9916,87 @@
/* num parameters */ 0,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
+ /* template types */ &kTemplateTypes[12],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[212],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[210],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
/* [161] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[925],
- /* return matcher indices */ &kMatcherIndices[212],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [162] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
/* template types */ &kTemplateTypes[12],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[922],
- /* return matcher indices */ &kMatcherIndices[212],
+ /* return matcher indices */ &kMatcherIndices[210],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
- /* [163] */
+ /* [162] */
/* num parameters */ 16,
/* num template types */ 1,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[11],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[0],
- /* return matcher indices */ &kMatcherIndices[212],
+ /* return matcher indices */ &kMatcherIndices[210],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::MatCtorS,
},
{
- /* [164] */
+ /* [163] */
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[11],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[411],
- /* return matcher indices */ &kMatcherIndices[212],
+ /* parameters */ &kParameters[443],
+ /* return matcher indices */ &kMatcherIndices[210],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [164] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[908],
+ /* return matcher indices */ &kMatcherIndices[214],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
},
{
/* [165] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
+ /* template types */ &kTemplateTypes[2],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[831],
- /* return matcher indices */ &kMatcherIndices[214],
+ /* parameters */ &kParameters[906],
+ /* return matcher indices */ &kMatcherIndices[212],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
/* [166] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[913],
- /* return matcher indices */ &kMatcherIndices[154],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [167] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[186],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [168] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1011],
- /* return matcher indices */ &kMatcherIndices[186],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [169] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1004],
- /* return matcher indices */ &kMatcherIndices[186],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [170] */
- /* num parameters */ 8,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[57],
- /* return matcher indices */ &kMatcherIndices[186],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [171] */
- /* num parameters */ 4,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[399],
- /* return matcher indices */ &kMatcherIndices[186],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [172] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[983],
- /* return matcher indices */ &kMatcherIndices[190],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [173] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[976],
- /* return matcher indices */ &kMatcherIndices[188],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [174] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[160],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [175] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[984],
- /* return matcher indices */ &kMatcherIndices[160],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [176] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[985],
- /* return matcher indices */ &kMatcherIndices[160],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [177] */
- /* num parameters */ 8,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[49],
- /* return matcher indices */ &kMatcherIndices[160],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [178] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[785],
- /* return matcher indices */ &kMatcherIndices[160],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [179] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[988],
- /* return matcher indices */ &kMatcherIndices[166],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [180] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[989],
- /* return matcher indices */ &kMatcherIndices[164],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [181] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[146],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [182] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[970],
- /* return matcher indices */ &kMatcherIndices[146],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [183] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[971],
- /* return matcher indices */ &kMatcherIndices[146],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [184] */
- /* num parameters */ 4,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[371],
- /* return matcher indices */ &kMatcherIndices[146],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [185] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[777],
- /* return matcher indices */ &kMatcherIndices[146],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [186] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[974],
- /* return matcher indices */ &kMatcherIndices[150],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [187] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[975],
- /* return matcher indices */ &kMatcherIndices[148],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [188] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[174],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [189] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[998],
- /* return matcher indices */ &kMatcherIndices[174],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [190] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[999],
- /* return matcher indices */ &kMatcherIndices[174],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [191] */
- /* num parameters */ 9,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[40],
- /* return matcher indices */ &kMatcherIndices[174],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [192] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[456],
- /* return matcher indices */ &kMatcherIndices[174],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [193] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1002],
- /* return matcher indices */ &kMatcherIndices[178],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [194] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1003],
- /* return matcher indices */ &kMatcherIndices[176],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [195] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[168],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [196] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[991],
- /* return matcher indices */ &kMatcherIndices[168],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [197] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[992],
- /* return matcher indices */ &kMatcherIndices[168],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [198] */
- /* num parameters */ 6,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[132],
- /* return matcher indices */ &kMatcherIndices[168],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [199] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[459],
- /* return matcher indices */ &kMatcherIndices[168],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [200] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[995],
- /* return matcher indices */ &kMatcherIndices[172],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [201] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[996],
- /* return matcher indices */ &kMatcherIndices[170],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [202] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[152],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [203] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[977],
- /* return matcher indices */ &kMatcherIndices[152],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [204] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[978],
- /* return matcher indices */ &kMatcherIndices[152],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [205] */
- /* num parameters */ 6,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[126],
- /* return matcher indices */ &kMatcherIndices[152],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [206] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[783],
- /* return matcher indices */ &kMatcherIndices[152],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [207] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[981],
- /* return matcher indices */ &kMatcherIndices[158],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [208] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[982],
- /* return matcher indices */ &kMatcherIndices[156],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [209] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[196],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [210] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[969],
- /* return matcher indices */ &kMatcherIndices[196],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [211] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[954],
- /* return matcher indices */ &kMatcherIndices[196],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [212] */
- /* num parameters */ 12,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[28],
- /* return matcher indices */ &kMatcherIndices[196],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [213] */
- /* num parameters */ 4,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[403],
- /* return matcher indices */ &kMatcherIndices[196],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [214] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[931],
- /* return matcher indices */ &kMatcherIndices[210],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [215] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[928],
- /* return matcher indices */ &kMatcherIndices[208],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [216] */
- /* num parameters */ 0,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[180],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [217] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[13],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1005],
- /* return matcher indices */ &kMatcherIndices[180],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [218] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[12],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1006],
- /* return matcher indices */ &kMatcherIndices[180],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [219] */
- /* num parameters */ 12,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[16],
- /* return matcher indices */ &kMatcherIndices[180],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [220] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[11],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[450],
- /* return matcher indices */ &kMatcherIndices[180],
- /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [221] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[4],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1009],
- /* return matcher indices */ &kMatcherIndices[184],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [222] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[2],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[914],
- /* return matcher indices */ &kMatcherIndices[182],
- /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [223] */
/* num parameters */ 4,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[395],
+ /* parameters */ &kParameters[419],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [224] */
+ /* [167] */
/* num parameters */ 5,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -10697,43 +10008,211 @@
/* const eval */ nullptr,
},
{
- /* [225] */
+ /* [168] */
/* num parameters */ 5,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[260],
+ /* parameters */ &kParameters[220],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [226] */
+ /* [169] */
/* num parameters */ 6,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[78],
+ /* parameters */ &kParameters[138],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [227] */
+ /* [170] */
/* num parameters */ 4,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[443],
+ /* parameters */ &kParameters[403],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [228] */
+ /* [171] */
+ /* num parameters */ 5,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[290],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [172] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[164],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [173] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[982],
+ /* return matcher indices */ &kMatcherIndices[164],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [174] */
+ /* num parameters */ 8,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[57],
+ /* return matcher indices */ &kMatcherIndices[164],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [175] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[593],
+ /* return matcher indices */ &kMatcherIndices[164],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [176] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[985],
+ /* return matcher indices */ &kMatcherIndices[168],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [177] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[986],
+ /* return matcher indices */ &kMatcherIndices[166],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [178] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[148],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [179] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[970],
+ /* return matcher indices */ &kMatcherIndices[148],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [180] */
+ /* num parameters */ 4,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[411],
+ /* return matcher indices */ &kMatcherIndices[148],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [181] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[597],
+ /* return matcher indices */ &kMatcherIndices[148],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [182] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[973],
+ /* return matcher indices */ &kMatcherIndices[154],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [183] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[974],
+ /* return matcher indices */ &kMatcherIndices[150],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [184] */
+ /* num parameters */ 4,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[395],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [185] */
/* num parameters */ 5,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -10741,174 +10220,690 @@
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[195],
/* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [229] */
- /* num parameters */ 4,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[307],
- /* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [230] */
+ /* [186] */
/* num parameters */ 5,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[230],
+ /* parameters */ &kParameters[155],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [231] */
- /* num parameters */ 5,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[235],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [232] */
+ /* [187] */
/* num parameters */ 6,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[96],
+ /* parameters */ &kParameters[72],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
+ /* [188] */
+ /* num parameters */ 4,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[371],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [189] */
+ /* num parameters */ 5,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[175],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [190] */
+ /* num parameters */ 4,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[367],
+ /* return matcher indices */ &kMatcherIndices[112],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [191] */
+ /* num parameters */ 5,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[185],
+ /* return matcher indices */ &kMatcherIndices[112],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [192] */
+ /* num parameters */ 5,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[190],
+ /* return matcher indices */ &kMatcherIndices[112],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [193] */
+ /* num parameters */ 6,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[126],
+ /* return matcher indices */ &kMatcherIndices[112],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [194] */
+ /* num parameters */ 4,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[355],
+ /* return matcher indices */ &kMatcherIndices[112],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [195] */
+ /* num parameters */ 5,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[210],
+ /* return matcher indices */ &kMatcherIndices[112],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [196] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[156],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [197] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[976],
+ /* return matcher indices */ &kMatcherIndices[156],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [198] */
+ /* num parameters */ 6,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[84],
+ /* return matcher indices */ &kMatcherIndices[156],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [199] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[595],
+ /* return matcher indices */ &kMatcherIndices[156],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [200] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[979],
+ /* return matcher indices */ &kMatcherIndices[162],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [201] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[980],
+ /* return matcher indices */ &kMatcherIndices[160],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [202] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[186],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [203] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[987],
+ /* return matcher indices */ &kMatcherIndices[186],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [204] */
+ /* num parameters */ 8,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[49],
+ /* return matcher indices */ &kMatcherIndices[186],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [205] */
+ /* num parameters */ 4,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[415],
+ /* return matcher indices */ &kMatcherIndices[186],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [206] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[969],
+ /* return matcher indices */ &kMatcherIndices[190],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [207] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[954],
+ /* return matcher indices */ &kMatcherIndices[188],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [208] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[192],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [209] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[943],
+ /* return matcher indices */ &kMatcherIndices[192],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [210] */
+ /* num parameters */ 12,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[16],
+ /* return matcher indices */ &kMatcherIndices[192],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [211] */
+ /* num parameters */ 4,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[391],
+ /* return matcher indices */ &kMatcherIndices[192],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [212] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[928],
+ /* return matcher indices */ &kMatcherIndices[204],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [213] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[925],
+ /* return matcher indices */ &kMatcherIndices[202],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [214] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[104],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [215] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1000],
+ /* return matcher indices */ &kMatcherIndices[104],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [216] */
+ /* num parameters */ 12,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[28],
+ /* return matcher indices */ &kMatcherIndices[104],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [217] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[468],
+ /* return matcher indices */ &kMatcherIndices[104],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [218] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[999],
+ /* return matcher indices */ &kMatcherIndices[184],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [219] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[993],
+ /* return matcher indices */ &kMatcherIndices[182],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [220] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[176],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [221] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[994],
+ /* return matcher indices */ &kMatcherIndices[176],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [222] */
+ /* num parameters */ 9,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[40],
+ /* return matcher indices */ &kMatcherIndices[176],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [223] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[582],
+ /* return matcher indices */ &kMatcherIndices[176],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [224] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[997],
+ /* return matcher indices */ &kMatcherIndices[180],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [225] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[998],
+ /* return matcher indices */ &kMatcherIndices[178],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [226] */
+ /* num parameters */ 0,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[170],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Zero,
+ },
+ {
+ /* [227] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[12],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[988],
+ /* return matcher indices */ &kMatcherIndices[170],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Identity,
+ },
+ {
+ /* [228] */
+ /* num parameters */ 6,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[114],
+ /* return matcher indices */ &kMatcherIndices[170],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorS,
+ },
+ {
+ /* [229] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[579],
+ /* return matcher indices */ &kMatcherIndices[170],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::MatCtorV,
+ },
+ {
+ /* [230] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[4],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[991],
+ /* return matcher indices */ &kMatcherIndices[174],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [231] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[2],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[992],
+ /* return matcher indices */ &kMatcherIndices[172],
+ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ &ConstEval::Conv,
+ },
+ {
+ /* [232] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[737],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
/* [233] */
- /* num parameters */ 4,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[303],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[735],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [234] */
- /* num parameters */ 5,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[250],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[733],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [235] */
- /* num parameters */ 4,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[327],
- /* return matcher indices */ &kMatcherIndices[106],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[731],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [236] */
- /* num parameters */ 5,
+ /* num parameters */ 2,
/* num template types */ 0,
- /* num template numbers */ 0,
+ /* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[200],
- /* return matcher indices */ &kMatcherIndices[106],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[729],
+ /* return matcher indices */ &kMatcherIndices[11],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [237] */
- /* num parameters */ 5,
- /* num template types */ 0,
+ /* num parameters */ 1,
+ /* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[205],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[885],
+ /* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [238] */
- /* num parameters */ 6,
- /* num template types */ 0,
+ /* num parameters */ 1,
+ /* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[102],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[884],
+ /* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [239] */
- /* num parameters */ 4,
+ /* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[311],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[883],
+ /* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [240] */
- /* num parameters */ 5,
+ /* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[225],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[882],
+ /* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [241] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[741],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 2,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[3],
+ /* parameters */ &kParameters[881],
+ /* return matcher indices */ &kMatcherIndices[38],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [242] */
/* num parameters */ 2,
/* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[747],
- /* return matcher indices */ &kMatcherIndices[31],
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[749],
+ /* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -10917,9 +10912,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[749],
+ /* parameters */ &kParameters[747],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -10929,9 +10924,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[753],
+ /* parameters */ &kParameters[745],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -10939,96 +10934,96 @@
{
/* [245] */
/* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 2,
- /* template types */ &kTemplateTypes[24],
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[757],
- /* return matcher indices */ &kMatcherIndices[11],
+ /* parameters */ &kParameters[743],
+ /* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [246] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[813],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 2,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[741],
+ /* return matcher indices */ &kMatcherIndices[11],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [247] */
- /* num parameters */ 1,
+ /* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[812],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* parameters */ &kParameters[701],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [248] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[811],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[699],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [249] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[810],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[695],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [250] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 2,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[3],
- /* parameters */ &kParameters[809],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[693],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [251] */
/* num parameters */ 2,
- /* num template types */ 1,
+ /* num template types */ 0,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[663],
- /* return matcher indices */ &kMatcherIndices[1],
+ /* parameters */ &kParameters[687],
+ /* return matcher indices */ &kMatcherIndices[17],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [252] */
/* num parameters */ 2,
- /* num template types */ 1,
+ /* num template types */ 0,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[679],
- /* return matcher indices */ &kMatcherIndices[31],
+ /* parameters */ &kParameters[685],
+ /* return matcher indices */ &kMatcherIndices[45],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -11036,11 +11031,11 @@
/* [253] */
/* num parameters */ 2,
/* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[683],
- /* return matcher indices */ &kMatcherIndices[31],
+ /* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -11049,9 +11044,9 @@
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[10],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[689],
+ /* parameters */ &kParameters[681],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
@@ -11060,125 +11055,17 @@
/* [255] */
/* num parameters */ 2,
/* num template types */ 0,
- /* num template numbers */ 2,
+ /* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[739],
- /* return matcher indices */ &kMatcherIndices[11],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[679],
+ /* return matcher indices */ &kMatcherIndices[17],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [256] */
/* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[681],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [257] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[649],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [258] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[653],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [259] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[657],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [260] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[667],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [261] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[669],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [262] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[671],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [263] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[673],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [264] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[675],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [265] */
- /* num parameters */ 2,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
@@ -11189,91 +11076,91 @@
/* const eval */ nullptr,
},
{
- /* [266] */
+ /* [257] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[10],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[691],
+ /* parameters */ &kParameters[675],
/* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [267] */
+ /* [258] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[10],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[693],
+ /* parameters */ &kParameters[673],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [268] */
+ /* [259] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[611],
+ /* parameters */ &kParameters[709],
/* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [269] */
+ /* [260] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[623],
+ /* parameters */ &kParameters[707],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [270] */
+ /* [261] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[639],
+ /* parameters */ &kParameters[705],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [271] */
+ /* [262] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[641],
+ /* parameters */ &kParameters[781],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [272] */
+ /* [263] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
+ /* parameters */ &kParameters[1004],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
- /* [273] */
+ /* [264] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -11282,34 +11169,34 @@
/* parameters */ &kParameters[920],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
- /* [274] */
+ /* [265] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[22],
+ /* template types */ &kTemplateTypes[21],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[921],
/* return matcher indices */ &kMatcherIndices[38],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
- /* [275] */
+ /* [266] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
+ /* parameters */ &kParameters[1004],
/* return matcher indices */ &kMatcherIndices[17],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
- /* [276] */
+ /* [267] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -11318,70 +11205,70 @@
/* parameters */ &kParameters[932],
/* return matcher indices */ &kMatcherIndices[17],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
- /* [277] */
+ /* [268] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[19],
+ /* template types */ &kTemplateTypes[17],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[933],
/* return matcher indices */ &kMatcherIndices[17],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
- /* [278] */
+ /* [269] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[66],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[51],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
- /* [279] */
+ /* [270] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[929],
- /* return matcher indices */ &kMatcherIndices[66],
+ /* return matcher indices */ &kMatcherIndices[51],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
- /* [280] */
+ /* [271] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[18],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[930],
- /* return matcher indices */ &kMatcherIndices[66],
+ /* return matcher indices */ &kMatcherIndices[51],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
- /* [281] */
+ /* [272] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
+ /* parameters */ &kParameters[1004],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
- /* [282] */
+ /* [273] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -11390,34 +11277,34 @@
/* parameters */ &kParameters[926],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
- /* [283] */
+ /* [274] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[20],
+ /* template types */ &kTemplateTypes[19],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[927],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
- /* [284] */
+ /* [275] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[18],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[510],
+ /* parameters */ &kParameters[540],
/* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [285] */
+ /* [276] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 1,
@@ -11429,7 +11316,7 @@
/* const eval */ nullptr,
},
{
- /* [286] */
+ /* [277] */
/* num parameters */ 3,
/* num template types */ 1,
/* num template numbers */ 1,
@@ -11441,43 +11328,43 @@
/* const eval */ nullptr,
},
{
- /* [287] */
+ /* [278] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* parameters */ &kParameters[1004],
+ /* return matcher indices */ &kMatcherIndices[66],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Zero,
},
{
- /* [288] */
+ /* [279] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[923],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* return matcher indices */ &kMatcherIndices[66],
/* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Identity,
},
{
- /* [289] */
+ /* [280] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[21],
+ /* template types */ &kTemplateTypes[20],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[924],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* return matcher indices */ &kMatcherIndices[66],
/* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::Conv,
},
{
- /* [290] */
+ /* [281] */
/* num parameters */ 3,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -11489,7 +11376,7 @@
/* const eval */ nullptr,
},
{
- /* [291] */
+ /* [282] */
/* num parameters */ 3,
/* num template types */ 0,
/* num template numbers */ 1,
@@ -11501,7 +11388,7 @@
/* const eval */ nullptr,
},
{
- /* [292] */
+ /* [283] */
/* num parameters */ 3,
/* num template types */ 0,
/* num template numbers */ 1,
@@ -11513,127 +11400,127 @@
/* const eval */ nullptr,
},
{
- /* [293] */
+ /* [284] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
+ /* template types */ &kTemplateTypes[23],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[860],
/* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::OpComplement,
},
{
- /* [294] */
+ /* [285] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
+ /* template types */ &kTemplateTypes[23],
/* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[861],
/* return matcher indices */ &kMatcherIndices[31],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
+ /* const eval */ &ConstEval::OpComplement,
},
{
- /* [295] */
+ /* [286] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[890],
+ /* parameters */ &kParameters[798],
/* return matcher indices */ &kMatcherIndices[225],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [296] */
+ /* [287] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[889],
- /* return matcher indices */ &kMatcherIndices[162],
+ /* parameters */ &kParameters[810],
+ /* return matcher indices */ &kMatcherIndices[158],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [297] */
+ /* [288] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[888],
+ /* parameters */ &kParameters[822],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [298] */
+ /* [289] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[887],
+ /* parameters */ &kParameters[823],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [299] */
+ /* [290] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[892],
+ /* parameters */ &kParameters[800],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [300] */
+ /* [291] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[891],
+ /* parameters */ &kParameters[799],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [301] */
+ /* [292] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[884],
+ /* parameters */ &kParameters[826],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [302] */
+ /* [293] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[883],
+ /* parameters */ &kParameters[830],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [303] */
+ /* [294] */
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 0,
@@ -11645,7 +11532,7 @@
/* const eval */ nullptr,
},
{
- /* [304] */
+ /* [295] */
/* num parameters */ 4,
/* num template types */ 1,
/* num template numbers */ 1,
@@ -11657,631 +11544,7 @@
/* const eval */ nullptr,
},
{
- /* [305] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[882],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [306] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[881],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [307] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[593],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [308] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[631],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [309] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[880],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [310] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[879],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [311] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[878],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [312] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[877],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [313] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[876],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [314] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[875],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [315] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[769],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [316] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[765],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [317] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[763],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [318] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[761],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [319] */
- /* num parameters */ 3,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[522],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [320] */
- /* num parameters */ 3,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[528],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [321] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[874],
- /* return matcher indices */ &kMatcherIndices[224],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [322] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[873],
- /* return matcher indices */ &kMatcherIndices[114],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [323] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[894],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [324] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[893],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [325] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[886],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [326] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[885],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [327] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[898],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [328] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[897],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [329] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[513],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [330] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[516],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [331] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[899],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [332] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[1012],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [333] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[901],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [334] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[900],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [335] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[687],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [336] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[685],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [337] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[866],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [338] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[865],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [339] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[903],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [340] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[902],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [341] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[905],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [342] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[904],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [343] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[864],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [344] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[857],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [345] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[856],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [346] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[855],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [347] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[907],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [348] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[906],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [349] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[853],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [350] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[852],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [351] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[851],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [352] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[850],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [353] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[849],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [354] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[848],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [355] */
- /* num parameters */ 3,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[567],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [356] */
- /* num parameters */ 3,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[570],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [357] */
+ /* [296] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -12293,859 +11556,691 @@
/* const eval */ nullptr,
},
{
- /* [358] */
+ /* [297] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[845],
+ /* parameters */ &kParameters[848],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [359] */
+ /* [298] */
/* num parameters */ 2,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[599],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [360] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[597],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [361] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[896],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [362] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[895],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [363] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[843],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [364] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[842],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [365] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[841],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [366] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[840],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [367] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[909],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [368] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[908],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [369] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[838],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [370] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[837],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [371] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[911],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [372] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[910],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [373] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[735],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [374] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[743],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [375] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1010],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [376] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[912],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
- /* const eval */ nullptr,
- },
- {
- /* [377] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[795],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [378] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[719],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [379] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[715],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [380] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[717],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [381] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[711],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [382] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[713],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [383] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[729],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [384] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[727],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [385] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[917],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [386] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[916],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [387] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[854],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [388] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[844],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [389] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[937],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [390] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[918],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [391] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[947],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [392] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[946],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [393] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[798],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [394] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[797],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [395] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[957],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [396] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[948],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [397] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[707],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [398] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[709],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [399] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[959],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [400] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[958],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [401] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[961],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [402] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[960],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [403] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[462],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [404] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[465],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [405] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[963],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [406] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[962],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [407] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[973],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [408] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[972],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [409] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[781],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [410] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[779],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [411] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[16],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[703],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [412] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[16],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[705],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [413] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[16],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[699],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [414] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[16],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[701],
- /* return matcher indices */ &kMatcherIndices[45],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [415] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[980],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [416] */
- /* num parameters */ 1,
+ /* [299] */
+ /* num parameters */ 2,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[979],
+ /* parameters */ &kParameters[777],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [417] */
+ /* [300] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[987],
+ /* parameters */ &kParameters[849],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [418] */
+ /* [301] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[986],
+ /* parameters */ &kParameters[850],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [302] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[851],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [303] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[852],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [419] */
+ /* [304] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[853],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [305] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[854],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [306] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[10],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[659],
+ /* parameters */ &kParameters[763],
/* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [420] */
+ /* [307] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
+ /* template types */ &kTemplateTypes[13],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[661],
+ /* parameters */ &kParameters[761],
/* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [421] */
- /* num parameters */ 1,
+ /* [308] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[759],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [309] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[757],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [310] */
+ /* num parameters */ 3,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[994],
+ /* parameters */ &kParameters[450],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [422] */
- /* num parameters */ 1,
+ /* [311] */
+ /* num parameters */ 3,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[993],
+ /* parameters */ &kParameters[447],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [423] */
+ /* [312] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1007],
- /* return matcher indices */ &kMatcherIndices[17],
+ /* parameters */ &kParameters[855],
+ /* return matcher indices */ &kMatcherIndices[224],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [424] */
+ /* [313] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[856],
+ /* return matcher indices */ &kMatcherIndices[122],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [314] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[802],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [315] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[801],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [316] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[824],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [317] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[825],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [318] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[806],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [319] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[805],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [320] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[459],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [321] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[456],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [322] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[808],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [323] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[807],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [324] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[886],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [325] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[809],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [326] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[739],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [327] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[703],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [328] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[887],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [329] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[888],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [330] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[811],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [331] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[1001],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [425] */
+ /* [332] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[997],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* parameters */ &kParameters[813],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
/* const eval */ nullptr,
},
{
- /* [426] */
+ /* [333] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[1008],
- /* return matcher indices */ &kMatcherIndices[17],
+ /* parameters */ &kParameters[812],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [334] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[889],
+ /* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [427] */
+ /* [335] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[890],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [336] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[943],
+ /* parameters */ &kParameters[891],
/* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [428] */
+ /* [337] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[990],
+ /* parameters */ &kParameters[892],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [429] */
+ /* [338] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[815],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [339] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[814],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [340] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[893],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [341] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[894],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [342] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[895],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [343] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[896],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [344] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[897],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [345] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[898],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [346] */
+ /* num parameters */ 3,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[567],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [347] */
+ /* num parameters */ 3,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[570],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [348] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[899],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [349] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[900],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [350] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[671],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [351] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[669],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [352] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[804],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [353] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[803],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [354] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -13157,23 +12252,815 @@
/* const eval */ nullptr,
},
{
- /* [430] */
+ /* [355] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[934],
+ /* parameters */ &kParameters[797],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [431] */
+ /* [356] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[984],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [357] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[978],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [358] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[817],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [359] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[816],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [360] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[964],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [361] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[963],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [362] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[819],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [363] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[818],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [364] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[619],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [365] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[615],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [366] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[821],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [367] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[820],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [368] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[635],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [369] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[631],
+ /* return matcher indices */ &kMatcherIndices[45],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [370] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[641],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [371] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[639],
+ /* return matcher indices */ &kMatcherIndices[45],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [372] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[649],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [373] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[645],
+ /* return matcher indices */ &kMatcherIndices[45],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [374] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[787],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [375] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[789],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [376] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[829],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [377] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[828],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [378] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 0,
- /* template types */ &kTemplateTypes[23],
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[1002],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [379] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[996],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [380] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[832],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [381] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[831],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [382] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[834],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [383] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[833],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [384] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[870],
+ /* return matcher indices */ &kMatcherIndices[38],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [385] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[869],
+ /* return matcher indices */ &kMatcherIndices[38],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [386] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[837],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [387] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[836],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [388] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[657],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [389] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[653],
+ /* return matcher indices */ &kMatcherIndices[45],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [390] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[839],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [391] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[838],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [392] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[841],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [393] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[840],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [394] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[537],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [395] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[534],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [396] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[843],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [397] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[842],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [398] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[845],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [399] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[844],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [400] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[613],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [401] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[751],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [402] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[16],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[659],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [403] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[16],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[599],
+ /* return matcher indices */ &kMatcherIndices[45],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [404] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[16],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[663],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [405] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[16],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[661],
+ /* return matcher indices */ &kMatcherIndices[45],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [406] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[934],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [407] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[931],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [408] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[957],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [409] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[946],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [410] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[691],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [411] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[689],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [412] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[959],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [413] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[958],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [414] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[975],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [415] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[971],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [416] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[981],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [417] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[977],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [418] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[989],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [419] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[983],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [420] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[995],
+ /* return matcher indices */ &kMatcherIndices[14],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [421] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[990],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [422] */
+ /* num parameters */ 1,
+ /* num template types */ 1,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[22],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[862],
/* return matcher indices */ &kMatcherIndices[1],
@@ -13181,11 +13068,11 @@
/* const eval */ nullptr,
},
{
- /* [432] */
+ /* [423] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 1,
- /* template types */ &kTemplateTypes[23],
+ /* template types */ &kTemplateTypes[22],
/* template numbers */ &kTemplateNumbers[6],
/* parameters */ &kParameters[863],
/* return matcher indices */ &kMatcherIndices[31],
@@ -13193,7 +13080,7 @@
/* const eval */ nullptr,
},
{
- /* [433] */
+ /* [424] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
@@ -13205,7 +13092,7 @@
/* const eval */ nullptr,
},
{
- /* [434] */
+ /* [425] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 1,
@@ -13217,51 +13104,159 @@
/* const eval */ nullptr,
},
{
- /* [435] */
+ /* [426] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[10],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[731],
+ /* parameters */ &kParameters[627],
/* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
+ /* [427] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[623],
+ /* return matcher indices */ &kMatcherIndices[31],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [428] */
+ /* num parameters */ 3,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[561],
+ /* return matcher indices */ &kMatcherIndices[194],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [429] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[753],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [430] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[755],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [431] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[765],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [432] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[767],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [433] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[769],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [434] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[771],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [435] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[10],
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[773],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
/* [436] */
/* num parameters */ 2,
/* num template types */ 1,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[733],
- /* return matcher indices */ &kMatcherIndices[31],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* template numbers */ &kTemplateNumbers[9],
+ /* parameters */ &kParameters[775],
+ /* return matcher indices */ &kMatcherIndices[1],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [437] */
- /* num parameters */ 3,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[531],
- /* return matcher indices */ &kMatcherIndices[200],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[667],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [438] */
/* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[645],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[665],
+ /* return matcher indices */ &kMatcherIndices[17],
+ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
@@ -13271,121 +13266,13 @@
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[10],
/* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[635],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [440] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[615],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [441] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[627],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [442] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[619],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [443] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[613],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [444] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[609],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [445] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[607],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [446] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[695],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [447] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[697],
- /* return matcher indices */ &kMatcherIndices[17],
- /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [448] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[10],
- /* template numbers */ &kTemplateNumbers[9],
- /* parameters */ &kParameters[605],
+ /* parameters */ &kParameters[591],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [449] */
+ /* [440] */
/* num parameters */ 1,
/* num template types */ 1,
/* num template numbers */ 1,
@@ -13397,103 +13284,103 @@
/* const eval */ nullptr,
},
{
- /* [450] */
+ /* [441] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
+ /* parameters */ &kParameters[1004],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [451] */
+ /* [442] */
/* num parameters */ 0,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[1013],
+ /* parameters */ &kParameters[1004],
/* return matcher indices */ nullptr,
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [452] */
+ /* [443] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[832],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[937],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [453] */
+ /* [444] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[833],
- /* return matcher indices */ &kMatcherIndices[106],
+ /* parameters */ &kParameters[947],
+ /* return matcher indices */ &kMatcherIndices[112],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [454] */
+ /* [445] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[834],
- /* return matcher indices */ &kMatcherIndices[108],
+ /* parameters */ &kParameters[948],
+ /* return matcher indices */ &kMatcherIndices[120],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [455] */
+ /* [446] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[835],
- /* return matcher indices */ &kMatcherIndices[108],
+ /* parameters */ &kParameters[961],
+ /* return matcher indices */ &kMatcherIndices[120],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [456] */
+ /* [447] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[836],
- /* return matcher indices */ &kMatcherIndices[108],
+ /* parameters */ &kParameters[962],
+ /* return matcher indices */ &kMatcherIndices[120],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [457] */
+ /* [448] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 2,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[5],
- /* parameters */ &kParameters[839],
+ /* parameters */ &kParameters[972],
/* return matcher indices */ &kMatcherIndices[19],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [458] */
+ /* [449] */
/* num parameters */ 3,
/* num template types */ 0,
/* num template numbers */ 1,
@@ -13505,26 +13392,134 @@
/* const eval */ nullptr,
},
{
- /* [459] */
+ /* [450] */
/* num parameters */ 2,
/* num template types */ 0,
/* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[665],
+ /* parameters */ &kParameters[697],
/* return matcher indices */ &kMatcherIndices[34],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
- /* [460] */
+ /* [451] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[868],
+ /* return matcher indices */ &kMatcherIndices[66],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [452] */
/* num parameters */ 1,
/* num template types */ 0,
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
/* parameters */ &kParameters[867],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* return matcher indices */ &kMatcherIndices[66],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [453] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[866],
+ /* return matcher indices */ &kMatcherIndices[66],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [454] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[865],
+ /* return matcher indices */ &kMatcherIndices[66],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [455] */
+ /* num parameters */ 1,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[857],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [456] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[785],
+ /* return matcher indices */ &kMatcherIndices[43],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [457] */
+ /* num parameters */ 3,
+ /* num template types */ 0,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[453],
+ /* return matcher indices */ &kMatcherIndices[34],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [458] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[795],
+ /* return matcher indices */ &kMatcherIndices[66],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [459] */
+ /* num parameters */ 2,
+ /* num template types */ 0,
+ /* num template numbers */ 0,
+ /* template types */ &kTemplateTypes[24],
+ /* template numbers */ &kTemplateNumbers[10],
+ /* parameters */ &kParameters[793],
+ /* return matcher indices */ &kMatcherIndices[38],
+ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
+ /* const eval */ nullptr,
+ },
+ {
+ /* [460] */
+ /* num parameters */ 2,
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[13],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[791],
+ /* return matcher indices */ &kMatcherIndices[1],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -13532,23 +13527,23 @@
/* [461] */
/* num parameters */ 1,
/* num template types */ 0,
- /* num template numbers */ 0,
+ /* num template numbers */ 1,
/* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[868],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* template numbers */ &kTemplateNumbers[6],
+ /* parameters */ &kParameters[827],
+ /* return matcher indices */ &kMatcherIndices[14],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
{
/* [462] */
/* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[869],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* num template types */ 1,
+ /* num template numbers */ 1,
+ /* template types */ &kTemplateTypes[15],
+ /* template numbers */ &kTemplateNumbers[8],
+ /* parameters */ &kParameters[960],
+ /* return matcher indices */ &kMatcherIndices[66],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -13559,116 +13554,8 @@
/* num template numbers */ 0,
/* template types */ &kTemplateTypes[24],
/* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[870],
- /* return matcher indices */ &kMatcherIndices[55],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [464] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[872],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [465] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[737],
- /* return matcher indices */ &kMatcherIndices[39],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [466] */
- /* num parameters */ 3,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[519],
- /* return matcher indices */ &kMatcherIndices[34],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [467] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[721],
- /* return matcher indices */ &kMatcherIndices[55],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [468] */
- /* num parameters */ 2,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[723],
- /* return matcher indices */ &kMatcherIndices[38],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [469] */
- /* num parameters */ 2,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[14],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[725],
- /* return matcher indices */ &kMatcherIndices[1],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [470] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[6],
- /* parameters */ &kParameters[915],
- /* return matcher indices */ &kMatcherIndices[14],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [471] */
- /* num parameters */ 1,
- /* num template types */ 1,
- /* num template numbers */ 1,
- /* template types */ &kTemplateTypes[17],
- /* template numbers */ &kTemplateNumbers[8],
- /* parameters */ &kParameters[1000],
- /* return matcher indices */ &kMatcherIndices[55],
- /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
- /* const eval */ nullptr,
- },
- {
- /* [472] */
- /* num parameters */ 1,
- /* num template types */ 0,
- /* num template numbers */ 0,
- /* template types */ &kTemplateTypes[24],
- /* template numbers */ &kTemplateNumbers[10],
- /* parameters */ &kParameters[871],
- /* return matcher indices */ &kMatcherIndices[55],
+ /* parameters */ &kParameters[864],
+ /* return matcher indices */ &kMatcherIndices[66],
/* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline),
/* const eval */ nullptr,
},
@@ -13680,357 +13567,357 @@
/* fn abs<T : fiu32>(T) -> T */
/* fn abs<N : num, T : fiu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[387],
+ /* overloads */ &kOverloads[378],
},
{
/* [1] */
/* fn acos(f32) -> f32 */
/* fn acos<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[429],
+ /* overloads */ &kOverloads[420],
},
{
/* [2] */
/* fn acosh(f32) -> f32 */
/* fn acosh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[427],
+ /* overloads */ &kOverloads[418],
},
{
/* [3] */
/* fn all(bool) -> bool */
/* fn all<N : num>(vec<N, bool>) -> bool */
/* num overloads */ 2,
- /* overloads */ &kOverloads[425],
+ /* overloads */ &kOverloads[416],
},
{
/* [4] */
/* fn any(bool) -> bool */
/* fn any<N : num>(vec<N, bool>) -> bool */
/* num overloads */ 2,
- /* overloads */ &kOverloads[423],
+ /* overloads */ &kOverloads[414],
},
{
/* [5] */
/* fn arrayLength<T, A : access>(ptr<storage, array<T>, A>) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[471],
+ /* overloads */ &kOverloads[462],
},
{
/* [6] */
/* fn asin(f32) -> f32 */
/* fn asin<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[421],
+ /* overloads */ &kOverloads[412],
},
{
/* [7] */
/* fn asinh(f32) -> f32 */
/* fn asinh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[417],
+ /* overloads */ &kOverloads[408],
},
{
/* [8] */
/* fn atan(f32) -> f32 */
/* fn atan<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[415],
+ /* overloads */ &kOverloads[406],
},
{
/* [9] */
/* fn atan2(f32, f32) -> f32 */
/* fn atan2<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[409],
+ /* overloads */ &kOverloads[400],
},
{
/* [10] */
/* fn atanh(f32) -> f32 */
/* fn atanh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[407],
+ /* overloads */ &kOverloads[398],
},
{
/* [11] */
/* fn ceil(f32) -> f32 */
/* fn ceil<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[405],
+ /* overloads */ &kOverloads[396],
},
{
/* [12] */
/* fn clamp<T : fiu32>(T, T, T) -> T */
/* fn clamp<N : num, T : fiu32>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[403],
+ /* overloads */ &kOverloads[394],
},
{
/* [13] */
/* fn cos(f32) -> f32 */
/* fn cos<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[401],
+ /* overloads */ &kOverloads[392],
},
{
/* [14] */
/* fn cosh(f32) -> f32 */
/* fn cosh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[399],
+ /* overloads */ &kOverloads[390],
},
{
/* [15] */
/* fn countLeadingZeros<T : iu32>(T) -> T */
/* fn countLeadingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[395],
+ /* overloads */ &kOverloads[386],
},
{
/* [16] */
/* fn countOneBits<T : iu32>(T) -> T */
/* fn countOneBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[391],
+ /* overloads */ &kOverloads[382],
},
{
/* [17] */
/* fn countTrailingZeros<T : iu32>(T) -> T */
/* fn countTrailingZeros<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[389],
+ /* overloads */ &kOverloads[380],
},
{
/* [18] */
/* fn cross(vec3<f32>, vec3<f32>) -> vec3<f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[465],
+ /* overloads */ &kOverloads[456],
},
{
/* [19] */
/* fn degrees(f32) -> f32 */
/* fn degrees<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[385],
+ /* overloads */ &kOverloads[376],
},
{
/* [20] */
/* fn determinant<N : num>(mat<N, N, f32>) -> f32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[470],
+ /* overloads */ &kOverloads[461],
},
{
/* [21] */
/* fn distance(f32, f32) -> f32 */
/* fn distance<N : num>(vec<N, f32>, vec<N, f32>) -> f32 */
/* num overloads */ 2,
- /* overloads */ &kOverloads[383],
+ /* overloads */ &kOverloads[374],
},
{
/* [22] */
/* fn dot<N : num, T : fiu32>(vec<N, T>, vec<N, T>) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[469],
+ /* overloads */ &kOverloads[460],
},
{
/* [23] */
/* fn dot4I8Packed(u32, u32) -> i32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[468],
+ /* overloads */ &kOverloads[459],
},
{
/* [24] */
/* fn dot4U8Packed(u32, u32) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[467],
+ /* overloads */ &kOverloads[458],
},
{
/* [25] */
/* fn dpdx(f32) -> f32 */
/* fn dpdx<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[375],
+ /* overloads */ &kOverloads[366],
},
{
/* [26] */
/* fn dpdxCoarse(f32) -> f32 */
/* fn dpdxCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[371],
+ /* overloads */ &kOverloads[362],
},
{
/* [27] */
/* fn dpdxFine(f32) -> f32 */
/* fn dpdxFine<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[367],
+ /* overloads */ &kOverloads[358],
},
{
/* [28] */
/* fn dpdy(f32) -> f32 */
/* fn dpdy<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[347],
+ /* overloads */ &kOverloads[338],
},
{
/* [29] */
/* fn dpdyCoarse(f32) -> f32 */
/* fn dpdyCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[341],
+ /* overloads */ &kOverloads[332],
},
{
/* [30] */
/* fn dpdyFine(f32) -> f32 */
/* fn dpdyFine<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[339],
+ /* overloads */ &kOverloads[330],
},
{
/* [31] */
/* fn exp(f32) -> f32 */
/* fn exp<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[333],
+ /* overloads */ &kOverloads[324],
},
{
/* [32] */
/* fn exp2(f32) -> f32 */
/* fn exp2<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[331],
+ /* overloads */ &kOverloads[322],
},
{
/* [33] */
/* fn extractBits<T : iu32>(T, u32, u32) -> T */
/* fn extractBits<N : num, T : iu32>(vec<N, T>, u32, u32) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[329],
+ /* overloads */ &kOverloads[320],
},
{
/* [34] */
/* fn faceForward<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[466],
+ /* overloads */ &kOverloads[457],
},
{
/* [35] */
/* fn firstLeadingBit<T : iu32>(T) -> T */
/* fn firstLeadingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[327],
+ /* overloads */ &kOverloads[318],
},
{
/* [36] */
/* fn firstTrailingBit<T : iu32>(T) -> T */
/* fn firstTrailingBit<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[361],
+ /* overloads */ &kOverloads[352],
},
{
/* [37] */
/* fn floor(f32) -> f32 */
/* fn floor<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[323],
+ /* overloads */ &kOverloads[314],
},
{
/* [38] */
/* fn fma(f32, f32, f32) -> f32 */
/* fn fma<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[319],
+ /* overloads */ &kOverloads[310],
},
{
/* [39] */
/* fn fract(f32) -> f32 */
/* fn fract<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[299],
+ /* overloads */ &kOverloads[290],
},
{
/* [40] */
/* fn frexp(f32) -> __frexp_result */
/* fn frexp<N : num>(vec<N, f32>) -> __frexp_result_vec<N> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[295],
+ /* overloads */ &kOverloads[286],
},
{
/* [41] */
/* fn fwidth(f32) -> f32 */
/* fn fwidth<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[297],
+ /* overloads */ &kOverloads[288],
},
{
/* [42] */
/* fn fwidthCoarse(f32) -> f32 */
/* fn fwidthCoarse<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[325],
+ /* overloads */ &kOverloads[316],
},
{
/* [43] */
/* fn fwidthFine(f32) -> f32 */
/* fn fwidthFine<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[301],
+ /* overloads */ &kOverloads[292],
},
{
/* [44] */
/* fn insertBits<T : iu32>(T, T, u32, u32) -> T */
/* fn insertBits<N : num, T : iu32>(vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[303],
+ /* overloads */ &kOverloads[294],
},
{
/* [45] */
/* fn inverseSqrt(f32) -> f32 */
/* fn inverseSqrt<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[305],
+ /* overloads */ &kOverloads[296],
},
{
/* [46] */
/* fn ldexp(f32, i32) -> f32 */
/* fn ldexp<N : num>(vec<N, f32>, vec<N, i32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[307],
+ /* overloads */ &kOverloads[298],
},
{
/* [47] */
/* fn length(f32) -> f32 */
/* fn length<N : num>(vec<N, f32>) -> f32 */
/* num overloads */ 2,
- /* overloads */ &kOverloads[309],
+ /* overloads */ &kOverloads[300],
},
{
/* [48] */
/* fn log(f32) -> f32 */
/* fn log<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[311],
+ /* overloads */ &kOverloads[302],
},
{
/* [49] */
/* fn log2(f32) -> f32 */
/* fn log2<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[313],
+ /* overloads */ &kOverloads[304],
},
{
/* [50] */
/* fn max<T : fiu32>(T, T) -> T */
/* fn max<N : num, T : fiu32>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[315],
+ /* overloads */ &kOverloads[306],
},
{
/* [51] */
/* fn min<T : fiu32>(T, T) -> T */
/* fn min<N : num, T : fiu32>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[317],
+ /* overloads */ &kOverloads[308],
},
{
/* [52] */
@@ -14038,90 +13925,90 @@
/* fn mix<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* fn mix<N : num>(vec<N, f32>, vec<N, f32>, f32) -> vec<N, f32> */
/* num overloads */ 3,
- /* overloads */ &kOverloads[290],
+ /* overloads */ &kOverloads[281],
},
{
/* [53] */
/* fn modf(f32) -> __modf_result */
/* fn modf<N : num>(vec<N, f32>) -> __modf_result_vec<N> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[321],
+ /* overloads */ &kOverloads[312],
},
{
/* [54] */
/* fn normalize<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[464],
+ /* overloads */ &kOverloads[455],
},
{
/* [55] */
/* fn pack2x16float(vec2<f32>) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[472],
+ /* overloads */ &kOverloads[463],
},
{
/* [56] */
/* fn pack2x16snorm(vec2<f32>) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[463],
+ /* overloads */ &kOverloads[454],
},
{
/* [57] */
/* fn pack2x16unorm(vec2<f32>) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[462],
+ /* overloads */ &kOverloads[453],
},
{
/* [58] */
/* fn pack4x8snorm(vec4<f32>) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[461],
+ /* overloads */ &kOverloads[452],
},
{
/* [59] */
/* fn pack4x8unorm(vec4<f32>) -> u32 */
/* num overloads */ 1,
- /* overloads */ &kOverloads[460],
+ /* overloads */ &kOverloads[451],
},
{
/* [60] */
/* fn pow(f32, f32) -> f32 */
/* fn pow<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[335],
+ /* overloads */ &kOverloads[326],
},
{
/* [61] */
/* fn radians(f32) -> f32 */
/* fn radians<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[337],
+ /* overloads */ &kOverloads[328],
},
{
/* [62] */
/* fn reflect<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[459],
+ /* overloads */ &kOverloads[450],
},
{
/* [63] */
/* fn refract<N : num>(vec<N, f32>, vec<N, f32>, f32) -> vec<N, f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[458],
+ /* overloads */ &kOverloads[449],
},
{
/* [64] */
/* fn reverseBits<T : iu32>(T) -> T */
/* fn reverseBits<N : num, T : iu32>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[343],
+ /* overloads */ &kOverloads[334],
},
{
/* [65] */
/* fn round(f32) -> f32 */
/* fn round<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[345],
+ /* overloads */ &kOverloads[336],
},
{
/* [66] */
@@ -14129,118 +14016,118 @@
/* fn select<T : scalar_no_f16, N : num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T> */
/* fn select<N : num, T : scalar_no_f16>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T> */
/* num overloads */ 3,
- /* overloads */ &kOverloads[284],
+ /* overloads */ &kOverloads[275],
},
{
/* [67] */
/* fn sign(f32) -> f32 */
/* fn sign<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[349],
+ /* overloads */ &kOverloads[340],
},
{
/* [68] */
/* fn sin(f32) -> f32 */
/* fn sin<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[351],
+ /* overloads */ &kOverloads[342],
},
{
/* [69] */
/* fn sinh(f32) -> f32 */
/* fn sinh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[353],
+ /* overloads */ &kOverloads[344],
},
{
/* [70] */
/* fn smoothstep(f32, f32, f32) -> f32 */
/* fn smoothstep<N : num>(vec<N, f32>, vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[355],
+ /* overloads */ &kOverloads[346],
},
{
/* [71] */
/* fn sqrt(f32) -> f32 */
/* fn sqrt<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[357],
+ /* overloads */ &kOverloads[348],
},
{
/* [72] */
/* fn step(f32, f32) -> f32 */
/* fn step<N : num>(vec<N, f32>, vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[359],
+ /* overloads */ &kOverloads[350],
},
{
/* [73] */
/* fn storageBarrier() */
/* num overloads */ 1,
- /* overloads */ &kOverloads[450],
+ /* overloads */ &kOverloads[441],
},
{
/* [74] */
/* fn tan(f32) -> f32 */
/* fn tan<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[363],
+ /* overloads */ &kOverloads[354],
},
{
/* [75] */
/* fn tanh(f32) -> f32 */
/* fn tanh<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[365],
+ /* overloads */ &kOverloads[356],
},
{
/* [76] */
/* fn transpose<M : num, N : num>(mat<M, N, f32>) -> mat<N, M, f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[457],
+ /* overloads */ &kOverloads[448],
},
{
/* [77] */
/* fn trunc(f32) -> f32 */
/* fn trunc<N : num>(vec<N, f32>) -> vec<N, f32> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[369],
+ /* overloads */ &kOverloads[360],
},
{
/* [78] */
/* fn unpack2x16float(u32) -> vec2<f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[456],
+ /* overloads */ &kOverloads[447],
},
{
/* [79] */
/* fn unpack2x16snorm(u32) -> vec2<f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[455],
+ /* overloads */ &kOverloads[446],
},
{
/* [80] */
/* fn unpack2x16unorm(u32) -> vec2<f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[454],
+ /* overloads */ &kOverloads[445],
},
{
/* [81] */
/* fn unpack4x8snorm(u32) -> vec4<f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[453],
+ /* overloads */ &kOverloads[444],
},
{
/* [82] */
/* fn unpack4x8unorm(u32) -> vec4<f32> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[452],
+ /* overloads */ &kOverloads[443],
},
{
/* [83] */
/* fn workgroupBarrier() */
/* num overloads */ 1,
- /* overloads */ &kOverloads[451],
+ /* overloads */ &kOverloads[442],
},
{
/* [84] */
@@ -14300,7 +14187,7 @@
/* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32> */
/* fn textureGatherCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> vec4<f32> */
/* num overloads */ 6,
- /* overloads */ &kOverloads[235],
+ /* overloads */ &kOverloads[190],
},
{
/* [87] */
@@ -14310,7 +14197,7 @@
/* fn textureNumLayers(texture: texture_depth_cube_array) -> i32 */
/* fn textureNumLayers<F : texel_format, A : write_only>(texture: texture_storage_2d_array<F, A>) -> i32 */
/* num overloads */ 5,
- /* overloads */ &kOverloads[246],
+ /* overloads */ &kOverloads[237],
},
{
/* [88] */
@@ -14332,7 +14219,7 @@
/* fn textureNumSamples<T : fiu32>(texture: texture_multisampled_2d<T>) -> i32 */
/* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> i32 */
/* num overloads */ 2,
- /* overloads */ &kOverloads[393],
+ /* overloads */ &kOverloads[384],
},
{
/* [90] */
@@ -14376,7 +14263,7 @@
/* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
/* fn textureSampleCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> f32 */
/* num overloads */ 6,
- /* overloads */ &kOverloads[223],
+ /* overloads */ &kOverloads[166],
},
{
/* [93] */
@@ -14387,7 +14274,7 @@
/* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 */
/* fn textureSampleCompareLevel(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: i32, depth_ref: f32) -> f32 */
/* num overloads */ 6,
- /* overloads */ &kOverloads[229],
+ /* overloads */ &kOverloads[184],
},
{
/* [94] */
@@ -14457,67 +14344,67 @@
/* [98] */
/* fn atomicLoad<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[449],
+ /* overloads */ &kOverloads[440],
},
{
/* [99] */
/* fn atomicStore<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) */
/* num overloads */ 1,
- /* overloads */ &kOverloads[448],
+ /* overloads */ &kOverloads[439],
},
{
/* [100] */
/* fn atomicAdd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[445],
+ /* overloads */ &kOverloads[436],
},
{
/* [101] */
/* fn atomicSub<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[444],
+ /* overloads */ &kOverloads[435],
},
{
/* [102] */
/* fn atomicMax<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[443],
+ /* overloads */ &kOverloads[434],
},
{
/* [103] */
/* fn atomicMin<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[442],
+ /* overloads */ &kOverloads[433],
},
{
/* [104] */
/* fn atomicAnd<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[441],
+ /* overloads */ &kOverloads[432],
},
{
/* [105] */
/* fn atomicOr<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[440],
+ /* overloads */ &kOverloads[431],
},
{
/* [106] */
/* fn atomicXor<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[439],
+ /* overloads */ &kOverloads[430],
},
{
/* [107] */
/* fn atomicExchange<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T */
/* num overloads */ 1,
- /* overloads */ &kOverloads[438],
+ /* overloads */ &kOverloads[429],
},
{
/* [108] */
/* fn atomicCompareExchangeWeak<T : iu32, S : workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T> */
/* num overloads */ 1,
- /* overloads */ &kOverloads[437],
+ /* overloads */ &kOverloads[428],
},
};
@@ -14527,21 +14414,21 @@
/* op !(bool) -> bool */
/* op !<N : num>(vec<N, bool>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[433],
+ /* overloads */ &kOverloads[424],
},
{
/* [1] */
- /* op ~<T : iu32>(T) -> T */
- /* op ~<T : iu32, N : num>(vec<N, T>) -> vec<N, T> */
+ /* op ~<T : aiu32>(T) -> T */
+ /* op ~<T : aiu32, N : num>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[293],
+ /* overloads */ &kOverloads[284],
},
{
/* [2] */
/* op -<T : fi32>(T) -> T */
/* op -<T : fi32, N : num>(vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[431],
+ /* overloads */ &kOverloads[422],
},
};
constexpr uint8_t kUnaryOperatorNot = 0;
@@ -14557,7 +14444,7 @@
/* op +<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
/* op +<N : num, M : num>(mat<N, M, f32>, mat<N, M, f32>) -> mat<N, M, f32> */
/* num overloads */ 5,
- /* overloads */ &kOverloads[251],
+ /* overloads */ &kOverloads[242],
},
{
/* [1] */
@@ -14567,7 +14454,7 @@
/* op -<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
/* op -<N : num, M : num>(mat<N, M, f32>, mat<N, M, f32>) -> mat<N, M, f32> */
/* num overloads */ 5,
- /* overloads */ &kOverloads[241],
+ /* overloads */ &kOverloads[232],
},
{
/* [2] */
@@ -14590,7 +14477,7 @@
/* op /<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
/* op /<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
/* num overloads */ 4,
- /* overloads */ &kOverloads[268],
+ /* overloads */ &kOverloads[259],
},
{
/* [4] */
@@ -14599,14 +14486,14 @@
/* op %<T : fiu32, N : num>(vec<N, T>, T) -> vec<N, T> */
/* op %<T : fiu32, N : num>(T, vec<N, T>) -> vec<N, T> */
/* num overloads */ 4,
- /* overloads */ &kOverloads[256],
+ /* overloads */ &kOverloads[247],
},
{
/* [5] */
/* op ^<T : iu32>(T, T) -> T */
/* op ^<T : iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[419],
+ /* overloads */ &kOverloads[410],
},
{
/* [6] */
@@ -14615,7 +14502,7 @@
/* op &<T : iu32>(T, T) -> T */
/* op &<T : iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 4,
- /* overloads */ &kOverloads[260],
+ /* overloads */ &kOverloads[251],
},
{
/* [7] */
@@ -14624,75 +14511,75 @@
/* op |<T : iu32>(T, T) -> T */
/* op |<T : iu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, T> */
/* num overloads */ 4,
- /* overloads */ &kOverloads[264],
+ /* overloads */ &kOverloads[255],
},
{
/* [8] */
/* op &&(bool, bool) -> bool */
/* num overloads */ 1,
- /* overloads */ &kOverloads[446],
+ /* overloads */ &kOverloads[437],
},
{
/* [9] */
/* op ||(bool, bool) -> bool */
/* num overloads */ 1,
- /* overloads */ &kOverloads[447],
+ /* overloads */ &kOverloads[438],
},
{
/* [10] */
/* op ==<T : scalar>(T, T) -> bool */
/* op ==<T : scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[413],
+ /* overloads */ &kOverloads[404],
},
{
/* [11] */
/* op !=<T : scalar>(T, T) -> bool */
/* op !=<T : scalar, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[411],
+ /* overloads */ &kOverloads[402],
},
{
/* [12] */
/* op <<T : fiu32>(T, T) -> bool */
/* op <<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[397],
+ /* overloads */ &kOverloads[388],
},
{
/* [13] */
/* op ><T : fiu32>(T, T) -> bool */
/* op ><T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[381],
+ /* overloads */ &kOverloads[372],
},
{
/* [14] */
/* op <=<T : fiu32>(T, T) -> bool */
/* op <=<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[379],
+ /* overloads */ &kOverloads[370],
},
{
/* [15] */
/* op >=<T : fiu32>(T, T) -> bool */
/* op >=<T : fiu32, N : num>(vec<N, T>, vec<N, T>) -> vec<N, bool> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[377],
+ /* overloads */ &kOverloads[368],
},
{
/* [16] */
/* op <<<T : iu32>(T, u32) -> T */
/* op <<<T : iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[435],
+ /* overloads */ &kOverloads[426],
},
{
/* [17] */
/* op >><T : iu32>(T, u32) -> T */
/* op >><T : iu32, N : num>(vec<N, T>, vec<N, u32>) -> vec<N, T> */
/* num overloads */ 2,
- /* overloads */ &kOverloads[373],
+ /* overloads */ &kOverloads[364],
},
};
constexpr uint8_t kBinaryOperatorPlus = 0;
@@ -14721,7 +14608,7 @@
/* ctor i32(i32) -> i32 */
/* conv i32<T : scalar_no_i32>(T) -> i32 */
/* num overloads */ 3,
- /* overloads */ &kOverloads[272],
+ /* overloads */ &kOverloads[263],
},
{
/* [1] */
@@ -14729,7 +14616,7 @@
/* ctor u32(u32) -> u32 */
/* conv u32<T : scalar_no_u32>(T) -> u32 */
/* num overloads */ 3,
- /* overloads */ &kOverloads[287],
+ /* overloads */ &kOverloads[278],
},
{
/* [2] */
@@ -14737,7 +14624,7 @@
/* ctor f32(f32) -> f32 */
/* conv f32<T : scalar_no_f32>(T) -> f32 */
/* num overloads */ 3,
- /* overloads */ &kOverloads[281],
+ /* overloads */ &kOverloads[272],
},
{
/* [3] */
@@ -14745,7 +14632,7 @@
/* ctor f16(f16) -> f16 */
/* conv f16<T : scalar_no_f16>(T) -> f16 */
/* num overloads */ 3,
- /* overloads */ &kOverloads[278],
+ /* overloads */ &kOverloads[269],
},
{
/* [4] */
@@ -14753,7 +14640,7 @@
/* ctor bool(bool) -> bool */
/* conv bool<T : scalar_no_bool>(T) -> bool */
/* num overloads */ 3,
- /* overloads */ &kOverloads[275],
+ /* overloads */ &kOverloads[266],
},
{
/* [5] */
@@ -14809,108 +14696,99 @@
/* [8] */
/* ctor mat2x2<T : f32f16>() -> mat2x2<T> */
/* ctor mat2x2<T : f32f16>(mat2x2<T>) -> mat2x2<T> */
- /* ctor mat2x2<T : af_f32>(T) -> mat2x2<T> */
/* ctor mat2x2<T : af_f32f16>(T, T, T, T) -> mat2x2<T> */
/* ctor mat2x2<T : af_f32f16>(vec2<T>, vec2<T>) -> mat2x2<T> */
/* conv mat2x2<T : f16>(mat2x2<f32>) -> mat2x2<f16> */
/* conv mat2x2<T : f32>(mat2x2<f16>) -> mat2x2<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[181],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[178],
},
{
/* [9] */
/* ctor mat2x3<T : f32f16>() -> mat2x3<T> */
/* ctor mat2x3<T : f32f16>(mat2x3<T>) -> mat2x3<T> */
- /* ctor mat2x3<T : af_f32>(T) -> mat2x3<T> */
/* ctor mat2x3<T : af_f32f16>(T, T, T, T, T, T) -> mat2x3<T> */
/* ctor mat2x3<T : af_f32f16>(vec3<T>, vec3<T>) -> mat2x3<T> */
/* conv mat2x3<T : f16>(mat2x3<f32>) -> mat2x3<f16> */
/* conv mat2x3<T : f32>(mat2x3<f16>) -> mat2x3<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[202],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[196],
},
{
/* [10] */
/* ctor mat2x4<T : f32f16>() -> mat2x4<T> */
/* ctor mat2x4<T : f32f16>(mat2x4<T>) -> mat2x4<T> */
- /* ctor mat2x4<T : af_f32>(T) -> mat2x4<T> */
/* ctor mat2x4<T : af_f32f16>(T, T, T, T, T, T, T, T) -> mat2x4<T> */
/* ctor mat2x4<T : af_f32f16>(vec4<T>, vec4<T>) -> mat2x4<T> */
/* conv mat2x4<T : f16>(mat2x4<f32>) -> mat2x4<f16> */
/* conv mat2x4<T : f32>(mat2x4<f16>) -> mat2x4<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[174],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[172],
},
{
/* [11] */
/* ctor mat3x2<T : f32f16>() -> mat3x2<T> */
/* ctor mat3x2<T : f32f16>(mat3x2<T>) -> mat3x2<T> */
- /* ctor mat3x2<T : af_f32>(T) -> mat3x2<T> */
/* ctor mat3x2<T : af_f32f16>(T, T, T, T, T, T) -> mat3x2<T> */
/* ctor mat3x2<T : af_f32f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T> */
/* conv mat3x2<T : f16>(mat3x2<f32>) -> mat3x2<f16> */
/* conv mat3x2<T : f32>(mat3x2<f16>) -> mat3x2<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[195],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[226],
},
{
/* [12] */
/* ctor mat3x3<T : f32f16>() -> mat3x3<T> */
/* ctor mat3x3<T : f32f16>(mat3x3<T>) -> mat3x3<T> */
- /* ctor mat3x3<T : af_f32>(T) -> mat3x3<T> */
/* ctor mat3x3<T : af_f32f16>(T, T, T, T, T, T, T, T, T) -> mat3x3<T> */
/* ctor mat3x3<T : af_f32f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T> */
/* conv mat3x3<T : f16>(mat3x3<f32>) -> mat3x3<f16> */
/* conv mat3x3<T : f32>(mat3x3<f16>) -> mat3x3<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[188],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[220],
},
{
/* [13] */
/* ctor mat3x4<T : f32f16>() -> mat3x4<T> */
/* ctor mat3x4<T : f32f16>(mat3x4<T>) -> mat3x4<T> */
- /* ctor mat3x4<T : af_f32>(T) -> mat3x4<T> */
/* ctor mat3x4<T : af_f32f16>(T, T, T, T, T, T, T, T, T, T, T, T) -> mat3x4<T> */
/* ctor mat3x4<T : af_f32f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T> */
/* conv mat3x4<T : f16>(mat3x4<f32>) -> mat3x4<f16> */
/* conv mat3x4<T : f32>(mat3x4<f16>) -> mat3x4<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[216],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[214],
},
{
/* [14] */
/* ctor mat4x2<T : f32f16>() -> mat4x2<T> */
/* ctor mat4x2<T : f32f16>(mat4x2<T>) -> mat4x2<T> */
- /* ctor mat4x2<T : af_f32>(T) -> mat4x2<T> */
/* ctor mat4x2<T : af_f32f16>(T, T, T, T, T, T, T, T) -> mat4x2<T> */
/* ctor mat4x2<T : af_f32f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T> */
/* conv mat4x2<T : f16>(mat4x2<f32>) -> mat4x2<f16> */
/* conv mat4x2<T : f32>(mat4x2<f16>) -> mat4x2<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[167],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[202],
},
{
/* [15] */
/* ctor mat4x3<T : f32f16>() -> mat4x3<T> */
/* ctor mat4x3<T : f32f16>(mat4x3<T>) -> mat4x3<T> */
- /* ctor mat4x3<T : af_f32>(T) -> mat4x3<T> */
/* ctor mat4x3<T : af_f32f16>(T, T, T, T, T, T, T, T, T, T, T, T) -> mat4x3<T> */
/* ctor mat4x3<T : af_f32f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T> */
/* conv mat4x3<T : f16>(mat4x3<f32>) -> mat4x3<f16> */
/* conv mat4x3<T : f32>(mat4x3<f16>) -> mat4x3<f32> */
- /* num overloads */ 7,
- /* overloads */ &kOverloads[209],
+ /* num overloads */ 6,
+ /* overloads */ &kOverloads[208],
},
{
/* [16] */
/* ctor mat4x4<T : f32f16>() -> mat4x4<T> */
/* ctor mat4x4<T : f32f16>(mat4x4<T>) -> mat4x4<T> */
- /* ctor mat4x4<T : af_f32>(T) -> mat4x4<T> */
/* ctor mat4x4<T : af_f32f16>(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> mat4x4<T> */
/* ctor mat4x4<T : af_f32f16>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T> */
/* conv mat4x4<T : f16>(mat4x4<f32>) -> mat4x4<f16> */
/* conv mat4x4<T : f32>(mat4x4<f16>) -> mat4x4<f32> */
- /* num overloads */ 7,
+ /* num overloads */ 6,
/* overloads */ &kOverloads[160],
},
};
diff --git a/src/tint/resolver/intrinsic_table.inl.tmpl b/src/tint/resolver/intrinsic_table.inl.tmpl
index 663013e..94edc39 100644
--- a/src/tint/resolver/intrinsic_table.inl.tmpl
+++ b/src/tint/resolver/intrinsic_table.inl.tmpl
@@ -103,7 +103,7 @@
{{- end }}
{{- if $o.IsDeprecated}}, OverloadFlag::kIsDeprecated{{end }}),
/* const eval */
-{{- if $o.ConstEvalFunction }} const_eval::{{$o.ConstEvalFunction}},
+{{- if $o.ConstEvalFunction }} {{template "ConstEvalFn" $o}},
{{- else }} nullptr,
{{- end }}
},
@@ -137,7 +137,7 @@
};
{{- range $i, $o := .UnaryOperators }}
-constexpr uint8_t kUnaryOperator{{template "OperatorName" $o.Name}} = {{$i}};
+constexpr uint8_t kUnaryOperator{{ template "ExpandName" $o.Name}} = {{$i}};
{{- end }}
constexpr IntrinsicInfo kBinaryOperators[] = {
@@ -154,7 +154,7 @@
};
{{- range $i, $o := .BinaryOperators }}
-constexpr uint8_t kBinaryOperator{{template "OperatorName" $o.Name}} = {{$i}};
+constexpr uint8_t kBinaryOperator{{ template "ExpandName" $o.Name}} = {{$i}};
{{- end }}
constexpr IntrinsicInfo kConstructorsAndConverters[] = {
@@ -455,7 +455,7 @@
{{- end -}}
{{- /* ------------------------------------------------------------------ */ -}}
-{{- define "OperatorName" -}}
+{{- define "ExpandName" -}}
{{- /* ------------------------------------------------------------------ */ -}}
{{- if eq . "<<" -}}ShiftLeft
{{- else if eq . "&" -}}And
@@ -478,6 +478,16 @@
{{- else if eq . "*" -}}Star
{{- else if eq . "/" -}}Divide
{{- else if eq . "%" -}}Modulo
-{{- else -}}<unknown-{{.}}>
+{{- else -}}{{.}}
{{- end -}}
{{- end -}}
+
+
+{{- /* ------------------------------------------------------------------ */ -}}
+{{- define "ConstEvalFn" -}}
+{{- /* ------------------------------------------------------------------ */ -}}
+ &ConstEval::
+{{- if eq .Kind "operator" -}}Op{{end -}}
+ {{template "ExpandName" .ConstEvalFunction}}
+{{- end -}}
+
diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc
index e2c2247..c9d9836 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -676,36 +676,38 @@
TEST_F(IntrinsicTableTest, MatchTypeConstructorImplicit) {
auto* i32 = create<sem::I32>();
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
- auto* result =
+ 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<sem::TypeConstructor>());
- 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);
+ ASSERT_NE(result.target, nullptr);
+ EXPECT_EQ(result.target->ReturnType(), vec3_i32);
+ EXPECT_TRUE(result.target->Is<sem::TypeConstructor>());
+ ASSERT_EQ(result.target->Parameters().size(), 3u);
+ EXPECT_EQ(result.target->Parameters()[0]->Type(), i32);
+ EXPECT_EQ(result.target->Parameters()[1]->Type(), i32);
+ EXPECT_EQ(result.target->Parameters()[2]->Type(), i32);
+ EXPECT_NE(result.const_eval_fn, nullptr);
}
TEST_F(IntrinsicTableTest, MatchTypeConstructorExplicit) {
auto* i32 = create<sem::I32>();
auto* vec3_i32 = create<sem::Vector>(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<sem::TypeConstructor>());
- 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);
+ auto result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {i32, i32, i32}, Source{{12, 34}});
+ ASSERT_NE(result.target, nullptr);
+ EXPECT_EQ(result.target->ReturnType(), vec3_i32);
+ EXPECT_TRUE(result.target->Is<sem::TypeConstructor>());
+ ASSERT_EQ(result.target->Parameters().size(), 3u);
+ EXPECT_EQ(result.target->Parameters()[0]->Type(), i32);
+ EXPECT_EQ(result.target->Parameters()[1]->Type(), i32);
+ EXPECT_EQ(result.target->Parameters()[2]->Type(), i32);
+ EXPECT_NE(result.const_eval_fn, nullptr);
}
TEST_F(IntrinsicTableTest, MismatchTypeConstructorImplicit) {
auto* i32 = create<sem::I32>();
auto* f32 = create<sem::F32>();
- auto* result =
+ auto result =
table->Lookup(CtorConvIntrinsic::kVec3, nullptr, {i32, f32, i32}, Source{{12, 34}});
- ASSERT_EQ(result, nullptr);
+ ASSERT_EQ(result.target, nullptr);
EXPECT_EQ(Diagnostics().str(), R"(12:34 error: no matching constructor for vec3(i32, f32, i32)
6 candidate constructors:
@@ -728,8 +730,8 @@
TEST_F(IntrinsicTableTest, MismatchTypeConstructorExplicit) {
auto* i32 = create<sem::I32>();
auto* f32 = create<sem::F32>();
- auto* result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {i32, f32, i32}, Source{{12, 34}});
- ASSERT_EQ(result, nullptr);
+ auto result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {i32, f32, i32}, Source{{12, 34}});
+ ASSERT_EQ(result.target, nullptr);
EXPECT_EQ(Diagnostics().str(),
R"(12:34 error: no matching constructor for vec3<i32>(i32, f32, i32)
@@ -755,19 +757,19 @@
auto* vec3_i32 = create<sem::Vector>(i32, 3u);
auto* f32 = create<sem::F32>();
auto* vec3_f32 = create<sem::Vector>(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<sem::TypeConversion>());
- ASSERT_EQ(result->Parameters().size(), 1u);
- EXPECT_EQ(result->Parameters()[0]->Type(), vec3_f32);
+ auto result = table->Lookup(CtorConvIntrinsic::kVec3, i32, {vec3_f32}, Source{{12, 34}});
+ ASSERT_NE(result.target, nullptr);
+ EXPECT_EQ(result.target->ReturnType(), vec3_i32);
+ EXPECT_TRUE(result.target->Is<sem::TypeConversion>());
+ ASSERT_EQ(result.target->Parameters().size(), 1u);
+ EXPECT_EQ(result.target->Parameters()[0]->Type(), vec3_f32);
}
TEST_F(IntrinsicTableTest, MismatchTypeConversion) {
auto* arr = create<sem::Array>(create<sem::U32>(), 0u, 4u, 4u, 4u, 4u);
auto* f32 = create<sem::F32>();
- auto* result = table->Lookup(CtorConvIntrinsic::kVec3, f32, {arr}, Source{{12, 34}});
- ASSERT_EQ(result, nullptr);
+ auto result = table->Lookup(CtorConvIntrinsic::kVec3, f32, {arr}, Source{{12, 34}});
+ ASSERT_EQ(result.target, nullptr);
EXPECT_EQ(Diagnostics().str(),
R"(12:34 error: no matching constructor for vec3<f32>(array<u32>)
@@ -804,10 +806,10 @@
auto* ai = create<sem::AbstractInt>();
auto* i32 = create<sem::I32>();
auto result = table->Lookup(CtorConvIntrinsic::kI32, nullptr, {ai}, Source{});
- ASSERT_NE(result, nullptr);
- EXPECT_EQ(result->ReturnType(), i32);
- EXPECT_EQ(result->Parameters().size(), 1u);
- EXPECT_EQ(result->Parameters()[0]->Type(), i32);
+ ASSERT_NE(result.target, nullptr);
+ EXPECT_EQ(result.target->ReturnType(), i32);
+ EXPECT_EQ(result.target->Parameters().size(), 1u);
+ EXPECT_EQ(result.target->Parameters()[0]->Type(), i32);
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 12fca5a..4c49cd1 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -91,6 +91,7 @@
Resolver::Resolver(ProgramBuilder* builder)
: builder_(builder),
diagnostics_(builder->Diagnostics()),
+ const_eval_(*builder),
intrinsic_table_(IntrinsicTable::Create(*builder)),
sem_(builder, dependencies_),
validator_(builder, sem_) {}
@@ -366,10 +367,11 @@
sem::Variable* sem = nullptr;
if (is_global) {
sem = builder_->create<sem::GlobalVariable>(
- v, ty, ast::StorageClass::kNone, ast::Access::kUndefined, /* constant_value */ nullptr,
- sem::BindingPoint{});
+ v, ty, sem::EvaluationStage::kRuntime, ast::StorageClass::kNone,
+ ast::Access::kUndefined, /* constant_value */ nullptr, sem::BindingPoint{});
} else {
- sem = builder_->create<sem::LocalVariable>(v, ty, ast::StorageClass::kNone,
+ sem = builder_->create<sem::LocalVariable>(v, ty, sem::EvaluationStage::kRuntime,
+ ast::StorageClass::kNone,
ast::Access::kUndefined, current_statement_,
/* constant_value */ nullptr);
}
@@ -420,8 +422,8 @@
}
auto* sem = builder_->create<sem::GlobalVariable>(
- v, ty, ast::StorageClass::kNone, ast::Access::kUndefined, /* constant_value */ nullptr,
- sem::BindingPoint{});
+ v, ty, sem::EvaluationStage::kOverride, ast::StorageClass::kNone, ast::Access::kUndefined,
+ /* constant_value */ nullptr, sem::BindingPoint{});
if (auto* id = ast::GetAttribute<ast::IdAttribute>(v->attributes)) {
sem->SetConstantId(static_cast<uint16_t>(id->value));
@@ -481,11 +483,11 @@
}
auto* sem = is_global ? static_cast<sem::Variable*>(builder_->create<sem::GlobalVariable>(
- c, ty, ast::StorageClass::kNone, ast::Access::kUndefined, value,
- sem::BindingPoint{}))
+ c, ty, sem::EvaluationStage::kConstant, ast::StorageClass::kNone,
+ ast::Access::kUndefined, value, sem::BindingPoint{}))
: static_cast<sem::Variable*>(builder_->create<sem::LocalVariable>(
- c, ty, ast::StorageClass::kNone, ast::Access::kUndefined,
- current_statement_, value));
+ c, ty, sem::EvaluationStage::kConstant, ast::StorageClass::kNone,
+ ast::Access::kUndefined, current_statement_, value));
sem->SetConstructor(rhs);
builder_->Sem().Add(c, sem);
@@ -566,12 +568,14 @@
if (auto bp = var->BindingPoint()) {
binding_point = {bp.group->value, bp.binding->value};
}
- sem = builder_->create<sem::GlobalVariable>(var, var_ty, storage_class, access,
+ sem = builder_->create<sem::GlobalVariable>(var, var_ty, sem::EvaluationStage::kRuntime,
+ storage_class, access,
/* constant_value */ nullptr, binding_point);
} else {
- sem = builder_->create<sem::LocalVariable>(
- var, var_ty, storage_class, access, current_statement_, /* constant_value */ nullptr);
+ sem = builder_->create<sem::LocalVariable>(var, var_ty, sem::EvaluationStage::kRuntime,
+ storage_class, access, current_statement_,
+ /* constant_value */ nullptr);
}
sem->SetConstructor(rhs);
@@ -1269,6 +1273,7 @@
[&](const ast::UnaryOpExpression* unary) -> sem::Expression* { return UnaryOp(unary); },
[&](const ast::PhonyExpression*) -> sem::Expression* {
return builder_->create<sem::Expression>(expr, builder_->create<sem::Void>(),
+ sem::EvaluationStage::kRuntime,
current_statement_,
/* constant_value */ nullptr,
/* has_side_effects */ false);
@@ -1313,7 +1318,7 @@
<< ") called on expression with no constant value";
return nullptr;
}
- auto materialized_val = ConvertValue(expr_val, target_ty, decl->source);
+ auto materialized_val = const_eval_.Convert(target_ty, expr_val, decl->source);
if (!materialized_val) {
// ConvertValue() has already failed and raised an diagnostic error.
return nullptr;
@@ -1422,10 +1427,11 @@
ty = builder_->create<sem::Reference>(ty, ref->StorageClass(), ref->Access());
}
- auto val = EvaluateIndexValue(obj, idx);
+ auto stage = sem::EarliestStage(obj->Stage(), idx->Stage());
+ auto val = const_eval_.Index(obj, idx);
bool has_side_effects = idx->HasSideEffects() || obj->HasSideEffects();
auto* sem = builder_->create<sem::IndexAccessorExpression>(
- expr, ty, obj, idx, current_statement_, std::move(val), has_side_effects,
+ expr, ty, stage, obj, idx, current_statement_, std::move(val), has_side_effects,
obj->SourceVariable());
sem->Behaviors() = idx->Behaviors() + obj->Behaviors();
return sem;
@@ -1441,9 +1447,10 @@
return nullptr;
}
- auto val = EvaluateBitcastValue(inner, ty);
- auto* sem = builder_->create<sem::Expression>(expr, ty, current_statement_, std::move(val),
- inner->HasSideEffects());
+ auto val = const_eval_.Bitcast(ty, inner);
+ auto stage = sem::EvaluationStage::kRuntime; // TODO(crbug.com/tint/1581)
+ auto* sem = builder_->create<sem::Expression>(expr, ty, stage, current_statement_,
+ std::move(val), inner->HasSideEffects());
sem->Behaviors() = inner->Behaviors();
@@ -1463,6 +1470,7 @@
// Resolve all of the arguments, their types and the set of behaviors.
std::vector<const sem::Expression*> args(expr->args.size());
+ auto args_stage = sem::EvaluationStage::kConstant;
sem::Behaviors arg_behaviors;
for (size_t i = 0; i < expr->args.size(); i++) {
auto* arg = sem_.Get(expr->args[i]);
@@ -1470,6 +1478,7 @@
return nullptr;
}
args[i] = arg;
+ args_stage = sem::EarliestStage(args_stage, arg->Stage());
arg_behaviors.Add(arg->Behaviors());
}
arg_behaviors.Remove(sem::Behavior::kNext);
@@ -1482,19 +1491,50 @@
// 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 arg_tys = utils::Transform(args, [](auto* arg) { return arg->Type(); });
- auto* call_target = intrinsic_table_->Lookup(ty, template_arg, arg_tys, expr->source);
- if (!call_target) {
+ auto ctor_or_conv = intrinsic_table_->Lookup(ty, template_arg, arg_tys, expr->source);
+ if (!ctor_or_conv.target) {
return nullptr;
}
+ if (!MaterializeArguments(args, ctor_or_conv.target)) {
+ return nullptr;
+ }
+ const sem::Constant* value = nullptr;
+ auto stage = sem::EarliestStage(ctor_or_conv.target->Stage(), args_stage);
+ if (stage == sem::EvaluationStage::kConstant) {
+ value = (const_eval_.*ctor_or_conv.const_eval_fn)(ctor_or_conv.target->ReturnType(),
+ args.data(), args.size());
+ }
+ return builder_->create<sem::Call>(expr, ctor_or_conv.target, stage, std::move(args),
+ current_statement_, value, has_side_effects);
+ };
+
+ // arr_or_str_ctor is a helper for building a sem::TypeConstructor for an array or structure
+ // constructor call target.
+ auto arr_or_str_ctor = [&](const sem::Type* ty,
+ const sem::CallTarget* call_target) -> sem::Call* {
if (!MaterializeArguments(args, call_target)) {
return nullptr;
}
- auto val = EvaluateCtorOrConvValue(args, call_target->ReturnType());
- return builder_->create<sem::Call>(expr, call_target, std::move(args), current_statement_,
- val, has_side_effects);
+
+ auto stage = args_stage; // The evaluation stage of the call
+ const sem::Constant* value = nullptr; // The constant value for the call
+ if (stage == sem::EvaluationStage::kConstant) {
+ value = const_eval_.ArrayOrStructCtor(ty, args);
+ if (!value) {
+ // Constant evaluation failed.
+ // Can happen for expressions that will fail validation (later).
+ // Use the kRuntime EvaluationStage, as kConstant will trigger an assertion in the
+ // sem::Expression constructor, which checks that kConstant is paired with a
+ // constant value.
+ stage = sem::EvaluationStage::kRuntime;
+ }
+ }
+
+ return builder_->create<sem::Call>(expr, call_target, stage, std::move(args),
+ current_statement_, value, has_side_effects);
};
- // ct_ctor_or_conv is a helper for building either a sem::TypeConstructor or sem::TypeConversion
+ // ty_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(
@@ -1512,7 +1552,7 @@
[&](const sem::Bool*) { return ct_ctor_or_conv(CtorConvIntrinsic::kBool, nullptr); },
[&](const sem::Array* arr) -> sem::Call* {
auto* call_target = utils::GetOrCreate(
- array_ctors_, ArrayConstructorSig{{arr, args.size()}},
+ array_ctors_, ArrayConstructorSig{{arr, args.size(), args_stage}},
[&]() -> sem::TypeConstructor* {
sem::ParameterList params(args.size());
for (size_t i = 0; i < args.size(); i++) {
@@ -1523,18 +1563,14 @@
ast::StorageClass::kNone, // storage_class
ast::Access::kUndefined); // access
}
- return builder_->create<sem::TypeConstructor>(arr, std::move(params));
+ return builder_->create<sem::TypeConstructor>(arr, std::move(params),
+ args_stage);
});
- if (!MaterializeArguments(args, call_target)) {
- return nullptr;
- }
- auto val = EvaluateCtorOrConvValue(args, arr);
- return builder_->create<sem::Call>(expr, call_target, std::move(args),
- current_statement_, val, has_side_effects);
+ return arr_or_str_ctor(arr, call_target);
},
[&](const sem::Struct* str) -> sem::Call* {
auto* call_target = utils::GetOrCreate(
- struct_ctors_, StructConstructorSig{{str, args.size()}},
+ struct_ctors_, StructConstructorSig{{str, args.size(), args_stage}},
[&]() -> sem::TypeConstructor* {
sem::ParameterList params(std::min(args.size(), str->Members().size()));
for (size_t i = 0, n = params.size(); i < n; i++) {
@@ -1545,15 +1581,10 @@
ast::StorageClass::kNone, // storage_class
ast::Access::kUndefined); // access
}
- return builder_->create<sem::TypeConstructor>(str, std::move(params));
+ return builder_->create<sem::TypeConstructor>(str, std::move(params),
+ args_stage);
});
- if (!MaterializeArguments(args, call_target)) {
- return nullptr;
- }
- auto val = EvaluateCtorOrConvValue(args, str);
- return builder_->create<sem::Call>(expr, call_target, std::move(args),
- current_statement_, std::move(val),
- has_side_effects);
+ return arr_or_str_ctor(str, call_target);
},
[&](Default) {
AddError("type is not constructible", expr->source);
@@ -1681,29 +1712,30 @@
AddWarning("use of deprecated builtin", expr->source);
}
+ auto stage = builtin.sem->Stage();
+ if (stage == sem::EvaluationStage::kConstant) { // <-- Optimization
+ // If the builtin is not annotated with @const, then it can only be evaluated
+ // at runtime, in which case there's no point checking the evaluation stage of the
+ // arguments.
+
+ // The builtin is @const annotated. Check all arguments are also constant.
+ for (auto* arg : args) {
+ stage = sem::EarliestStage(stage, arg->Stage());
+ }
+ }
+
// If the builtin is @const, and all arguments have constant values, evaluate the builtin now.
- const sem::Constant* constant = nullptr;
- if (builtin.const_eval_fn) {
- std::vector<const sem::Constant*> values(args.size());
- bool is_const = true; // all arguments have constant values
- for (size_t i = 0; i < values.size(); i++) {
- if (auto v = args[i]->ConstantValue()) {
- values[i] = std::move(v);
- } else {
- is_const = false;
- break;
- }
- }
- if (is_const) {
- constant = builtin.const_eval_fn(*builder_, values.data(), args.size());
- }
+ const sem::Constant* value = nullptr;
+ if (stage == sem::EvaluationStage::kConstant) {
+ value = (const_eval_.*builtin.const_eval_fn)(builtin.sem->ReturnType(), args.data(),
+ args.size());
}
bool has_side_effects =
builtin.sem->HasSideEffects() ||
std::any_of(args.begin(), args.end(), [](auto* e) { return e->HasSideEffects(); });
- auto* call = builder_->create<sem::Call>(expr, builtin.sem, std::move(args), current_statement_,
- constant, has_side_effects);
+ auto* call = builder_->create<sem::Call>(expr, builtin.sem, stage, std::move(args),
+ current_statement_, value, has_side_effects);
if (current_function_) {
current_function_->AddDirectlyCalledBuiltin(builtin.sem);
@@ -1761,7 +1793,8 @@
// TODO(crbug.com/tint/1420): For now, assume all function calls have side
// effects.
bool has_side_effects = true;
- auto* call = builder_->create<sem::Call>(expr, target, std::move(args), current_statement_,
+ auto* call = builder_->create<sem::Call>(expr, target, sem::EvaluationStage::kRuntime,
+ std::move(args), current_statement_,
/* constant_value */ nullptr, has_side_effects);
target->AddCallSite(call);
@@ -1856,8 +1889,9 @@
return nullptr;
}
- auto val = EvaluateLiteralValue(literal, ty);
- return builder_->create<sem::Expression>(literal, ty, current_statement_, std::move(val),
+ auto val = const_eval_.Literal(ty, literal);
+ return builder_->create<sem::Expression>(literal, ty, sem::EvaluationStage::kConstant,
+ current_statement_, std::move(val),
/* has_side_effects */ false);
}
@@ -1976,7 +2010,7 @@
ret = builder_->create<sem::Reference>(ret, ref->StorageClass(), ref->Access());
}
- auto* val = EvaluateMemberAccessValue(object, member);
+ auto* val = const_eval_.MemberAccess(object, member);
return builder_->create<sem::StructMemberAccess>(expr, ret, current_statement_, val, object,
member, has_side_effects, source_var);
}
@@ -2044,7 +2078,7 @@
// the swizzle.
ret = builder_->create<sem::Vector>(vec->type(), static_cast<uint32_t>(size));
}
- auto* val = EvaluateSwizzleValue(object, ret, swizzle);
+ auto* val = const_eval_.Swizzle(ret, object, swizzle);
return builder_->create<sem::Swizzle>(expr, ret, current_statement_, val, object,
std::move(swizzle), has_side_effects, source_var);
}
@@ -2060,6 +2094,7 @@
const auto* rhs = sem_.Get(expr->rhs);
auto* lhs_ty = lhs->Type()->UnwrapRef();
auto* rhs_ty = rhs->Type()->UnwrapRef();
+ auto stage = sem::EvaluationStage::kRuntime; // TODO(crbug.com/tint/1581)
auto op = intrinsic_table_->Lookup(expr->op, lhs_ty, rhs_ty, expr->source, false);
if (!op.result) {
@@ -2078,9 +2113,14 @@
}
}
- auto* val = EvaluateBinaryValue(lhs, rhs, op);
+ const sem::Constant* value = nullptr;
+ if (op.const_eval_fn) {
+ const sem::Expression* args[] = {lhs, rhs};
+ value = (const_eval_.*op.const_eval_fn)(op.result, args, 2u);
+ }
+
bool has_side_effects = lhs->HasSideEffects() || rhs->HasSideEffects();
- auto* sem = builder_->create<sem::Expression>(expr, op.result, current_statement_, val,
+ auto* sem = builder_->create<sem::Expression>(expr, op.result, stage, current_statement_, value,
has_side_effects);
sem->Behaviors() = lhs->Behaviors() + rhs->Behaviors();
@@ -2096,7 +2136,8 @@
const sem::Type* ty = nullptr;
const sem::Variable* source_var = nullptr;
- const sem::Constant* val = nullptr;
+ const sem::Constant* value = nullptr;
+ auto stage = sem::EvaluationStage::kRuntime;
switch (unary->op) {
case ast::UnaryOp::kAddressOf:
@@ -2148,13 +2189,20 @@
return nullptr;
}
}
+ stage = expr->Stage();
+ if (stage == sem::EvaluationStage::kConstant) {
+ if (op.const_eval_fn) {
+ value = (const_eval_.*op.const_eval_fn)(ty, &expr, 1u);
+ } else {
+ stage = sem::EvaluationStage::kRuntime;
+ }
+ }
ty = op.result;
- val = EvaluateUnaryValue(expr, op);
break;
}
}
- auto* sem = builder_->create<sem::Expression>(unary, ty, current_statement_, val,
+ auto* sem = builder_->create<sem::Expression>(unary, ty, stage, current_statement_, value,
expr->HasSideEffects(), source_var);
sem->Behaviors() = expr->Behaviors();
return sem;
@@ -2575,7 +2623,7 @@
sem->Behaviors() = ctor->Behaviors();
}
- return validator_.Variable(variable);
+ return validator_.LocalVariable(variable);
});
}
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index 20f487c..f3aa38b 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -24,6 +24,7 @@
#include <vector>
#include "src/tint/program_builder.h"
+#include "src/tint/resolver/const_eval.h"
#include "src/tint/resolver/dependency_graph.h"
#include "src/tint/resolver/intrinsic_table.h"
#include "src/tint/resolver/sem_helper.h"
@@ -34,7 +35,6 @@
#include "src/tint/sem/constant.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/struct.h"
-#include "src/tint/utils/result.h"
#include "src/tint/utils/unique_vector.h"
// Forward declarations
@@ -204,46 +204,6 @@
sem::Expression* MemberAccessor(const ast::MemberAccessorExpression*);
sem::Expression* UnaryOp(const ast::UnaryOpExpression*);
- ////////////////////////////////////////////////////////////////////////////////////////////////
- /// Constant value evaluation methods
- ///
- /// These methods are called from the expression resolving methods, and so child-expression
- /// nodes are guaranteed to have been already resolved and any constant values calculated.
- ////////////////////////////////////////////////////////////////////////////////////////////////
- const sem::Constant* EvaluateBinaryValue(const sem::Expression* lhs,
- const sem::Expression* rhs,
- const IntrinsicTable::BinaryOperator&);
- const sem::Constant* EvaluateBitcastValue(const sem::Expression*, const sem::Type*);
- const sem::Constant* EvaluateCtorOrConvValue(
- const std::vector<const sem::Expression*>& args,
- const sem::Type* ty); // Note: ty is not an array or structure
- const sem::Constant* EvaluateIndexValue(const sem::Expression* obj, const sem::Expression* idx);
- const sem::Constant* EvaluateLiteralValue(const ast::LiteralExpression*, const sem::Type*);
- const sem::Constant* EvaluateMemberAccessValue(const sem::Expression* obj,
- const sem::StructMember* member);
- const sem::Constant* EvaluateSwizzleValue(const sem::Expression* vector,
- const sem::Type* type,
- const std::vector<uint32_t>& indices);
- const sem::Constant* EvaluateUnaryValue(const sem::Expression*,
- const IntrinsicTable::UnaryOperator&);
-
- /// The result type of a ConstantEvaluation method.
- /// Can be one of three distinct values:
- /// * A non-null sem::Constant pointer. Returned when a expression resolves to a creation time
- /// value.
- /// * A null sem::Constant pointer. Returned when a expression cannot resolve to a creation time
- /// value, but is otherwise legal.
- /// * `utils::Failure`. Returned when there was a resolver error. In this situation the method
- /// will have already reported a diagnostic error message, and the caller should abort
- /// resolving.
- using ConstantResult = utils::Result<const sem::Constant*>;
-
- /// Convert the `value` to `target_type`
- /// @return the converted value
- ConstantResult ConvertValue(const sem::Constant* value,
- const sem::Type* target_type,
- const Source& source);
-
/// If `expr` is not of an abstract-numeric type, then Materialize() will just return `expr`.
/// If `expr` is of an abstract-numeric type:
/// * Materialize will create and return a sem::Materialize node wrapping `expr`.
@@ -440,15 +400,19 @@
bool IsBuiltin(Symbol) const;
// ArrayConstructorSig represents a unique array constructor signature.
- // It is a tuple of the array type and number of arguments provided.
- using ArrayConstructorSig = utils::UnorderedKeyWrapper<std::tuple<const sem::Array*, size_t>>;
+ // It is a tuple of the array type, number of arguments provided and earliest evaluation stage.
+ using ArrayConstructorSig =
+ utils::UnorderedKeyWrapper<std::tuple<const sem::Array*, size_t, sem::EvaluationStage>>;
// StructConstructorSig represents a unique structure constructor signature.
- // It is a tuple of the structure type and number of arguments provided.
- using StructConstructorSig = utils::UnorderedKeyWrapper<std::tuple<const sem::Struct*, size_t>>;
+ // It is a tuple of the structure type, number of arguments provided and earliest evaluation
+ // stage.
+ using StructConstructorSig =
+ utils::UnorderedKeyWrapper<std::tuple<const sem::Struct*, size_t, sem::EvaluationStage>>;
ProgramBuilder* const builder_;
diag::List& diagnostics_;
+ ConstEval const_eval_;
std::unique_ptr<IntrinsicTable> const intrinsic_table_;
DependencyGraph dependencies_;
SemHelper sem_;
diff --git a/src/tint/resolver/resolver_constants.cc b/src/tint/resolver/resolver_constants.cc
deleted file mode 100644
index c5798be..0000000
--- a/src/tint/resolver/resolver_constants.cc
+++ /dev/null
@@ -1,605 +0,0 @@
-// 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.
-
-#include "src/tint/resolver/resolver.h"
-
-#include <optional>
-
-#include "src/tint/sem/abstract_float.h"
-#include "src/tint/sem/abstract_int.h"
-#include "src/tint/sem/constant.h"
-#include "src/tint/sem/member_accessor_expression.h"
-#include "src/tint/sem/type_constructor.h"
-#include "src/tint/utils/compiler_macros.h"
-#include "src/tint/utils/map.h"
-#include "src/tint/utils/transform.h"
-
-using namespace tint::number_suffixes; // NOLINT
-
-namespace tint::resolver {
-
-namespace {
-
-/// TypeDispatch is a helper for calling the function `f`, passing a single zero-value argument of
-/// the C++ type that corresponds to the sem::Type `type`. For example, calling `TypeDispatch()`
-/// with a type of `sem::I32*` will call the function f with a single argument of `i32(0)`.
-/// @returns the value returned by calling `f`.
-/// @note `type` must be a scalar or abstract numeric type. Other types will not call `f`, and will
-/// return the zero-initialized value of the return type for `f`.
-template <typename F>
-auto TypeDispatch(const sem::Type* type, F&& f) {
- return Switch(
- type, //
- [&](const sem::AbstractInt*) { return f(AInt(0)); }, //
- [&](const sem::AbstractFloat*) { return f(AFloat(0)); }, //
- [&](const sem::I32*) { return f(i32(0)); }, //
- [&](const sem::U32*) { return f(u32(0)); }, //
- [&](const sem::F32*) { return f(f32(0)); }, //
- [&](const sem::F16*) { return f(f16(0)); }, //
- [&](const sem::Bool*) { return f(static_cast<bool>(0)); });
-}
-
-/// @returns `value` if `T` is not a Number, otherwise ValueOf returns the inner value of the
-/// Number.
-template <typename T>
-inline auto ValueOf(T value) {
- if constexpr (std::is_same_v<UnwrapNumber<T>, T>) {
- return value;
- } else {
- return value.value;
- }
-}
-
-/// @returns true if `value` is a positive zero.
-template <typename T>
-inline bool IsPositiveZero(T value) {
- using N = UnwrapNumber<T>;
- return Number<N>(value) == Number<N>(0); // Considers sign bit
-}
-
-/// Constant inherits from sem::Constant to add an private implementation method for conversion.
-struct Constant : public sem::Constant {
- /// Convert attempts to convert the constant value to the given type. On error, Convert()
- /// creates a new diagnostic message and returns a Failure.
- virtual utils::Result<const Constant*> Convert(ProgramBuilder& builder,
- const sem::Type* target_ty,
- const Source& source) const = 0;
-};
-
-// Forward declaration
-const Constant* CreateComposite(ProgramBuilder& builder,
- const sem::Type* type,
- std::vector<const Constant*> elements);
-
-/// Element holds a single scalar or abstract-numeric value.
-/// Element implements the Constant interface.
-template <typename T>
-struct Element : Constant {
- Element(const sem::Type* t, T v) : type(t), value(v) {}
- ~Element() override = default;
- const sem::Type* Type() const override { return type; }
- std::variant<std::monostate, AInt, AFloat> Value() const override {
- if constexpr (IsFloatingPoint<UnwrapNumber<T>>) {
- return static_cast<AFloat>(value);
- } else {
- return static_cast<AInt>(value);
- }
- }
- const Constant* Index(size_t) const override { return nullptr; }
- bool AllZero() const override { return IsPositiveZero(value); }
- bool AnyZero() const override { return IsPositiveZero(value); }
- bool AllEqual() const override { return true; }
- size_t Hash() const override { return utils::Hash(type, ValueOf(value)); }
-
- utils::Result<const Constant*> Convert(ProgramBuilder& builder,
- const sem::Type* target_ty,
- const Source& source) const override {
- TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
- if (target_ty == type) {
- // If the types are identical, then no conversion is needed.
- return this;
- }
- bool failed = false;
- auto* res = TypeDispatch(target_ty, [&](auto zero_to) -> const Constant* {
- // `T` is the source type, `value` is the source value.
- // `TO` is the target type.
- using TO = std::decay_t<decltype(zero_to)>;
- if constexpr (std::is_same_v<TO, bool>) {
- // [x -> bool]
- return builder.create<Element<TO>>(target_ty, !IsPositiveZero(value));
- } else if constexpr (std::is_same_v<T, bool>) {
- // [bool -> x]
- return builder.create<Element<TO>>(target_ty, TO(value ? 1 : 0));
- } else if (auto conv = CheckedConvert<TO>(value)) {
- // Conversion success
- return builder.create<Element<TO>>(target_ty, conv.Get());
- // --- Below this point are the failure cases ---
- } else if constexpr (std::is_same_v<T, AInt> || std::is_same_v<T, AFloat>) {
- // [abstract-numeric -> x] - materialization failure
- std::stringstream ss;
- ss << "value " << value << " cannot be represented as ";
- ss << "'" << builder.FriendlyName(target_ty) << "'";
- builder.Diagnostics().add_error(tint::diag::System::Resolver, ss.str(), source);
- failed = true;
- } else if constexpr (IsFloatingPoint<UnwrapNumber<TO>>) {
- // [x -> floating-point] - number not exactly representable
- // https://www.w3.org/TR/WGSL/#floating-point-conversion
- constexpr auto kInf = std::numeric_limits<double>::infinity();
- switch (conv.Failure()) {
- case ConversionFailure::kExceedsNegativeLimit:
- return builder.create<Element<TO>>(target_ty, TO(-kInf));
- case ConversionFailure::kExceedsPositiveLimit:
- return builder.create<Element<TO>>(target_ty, TO(kInf));
- }
- } else {
- // [x -> integer] - number not exactly representable
- // https://www.w3.org/TR/WGSL/#floating-point-conversion
- switch (conv.Failure()) {
- case ConversionFailure::kExceedsNegativeLimit:
- return builder.create<Element<TO>>(target_ty, TO(TO::kLowest));
- case ConversionFailure::kExceedsPositiveLimit:
- return builder.create<Element<TO>>(target_ty, TO(TO::kHighest));
- }
- }
- return nullptr; // Expression is not constant.
- });
- if (failed) {
- // A diagnostic error has been raised, and resolving should abort.
- return utils::Failure;
- }
- return res;
- TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
- }
-
- sem::Type const* const type;
- const T value;
-};
-
-/// Splat holds a single Constant value, duplicated as all children.
-/// Splat is used for zero-initializers, 'splat' constructors, or constructors where each element is
-/// identical. Splat may be of a vector, matrix or array type.
-/// Splat implements the Constant interface.
-struct Splat : Constant {
- Splat(const sem::Type* t, const Constant* e, size_t n) : type(t), el(e), count(n) {}
- ~Splat() override = default;
- const sem::Type* Type() const override { return type; }
- std::variant<std::monostate, AInt, AFloat> Value() const override { return {}; }
- const Constant* Index(size_t i) const override { return i < count ? el : nullptr; }
- bool AllZero() const override { return el->AllZero(); }
- bool AnyZero() const override { return el->AnyZero(); }
- bool AllEqual() const override { return true; }
- size_t Hash() const override { return utils::Hash(type, el->Hash(), count); }
-
- utils::Result<const Constant*> Convert(ProgramBuilder& builder,
- const sem::Type* target_ty,
- const Source& source) const override {
- // Convert the single splatted element type.
- auto conv_el = el->Convert(builder, sem::Type::ElementOf(target_ty), source);
- if (!conv_el) {
- return utils::Failure;
- }
- if (!conv_el.Get()) {
- return nullptr;
- }
- return builder.create<Splat>(target_ty, conv_el.Get(), count);
- }
-
- sem::Type const* const type;
- const Constant* el;
- const size_t count;
-};
-
-/// Composite holds a number of mixed child Constant values.
-/// Composite may be of a vector, matrix or array type.
-/// If each element is the same type and value, then a Splat would be a more efficient constant
-/// implementation. Use CreateComposite() to create the appropriate Constant type.
-/// Composite implements the Constant interface.
-struct Composite : Constant {
- Composite(const sem::Type* t, std::vector<const Constant*> els, bool all_0, bool any_0)
- : type(t), elements(std::move(els)), all_zero(all_0), any_zero(any_0), hash(CalcHash()) {}
- ~Composite() override = default;
- const sem::Type* Type() const override { return type; }
- std::variant<std::monostate, AInt, AFloat> Value() const override { return {}; }
- const Constant* Index(size_t i) const override {
- return i < elements.size() ? elements[i] : nullptr;
- }
- bool AllZero() const override { return all_zero; }
- bool AnyZero() const override { return any_zero; }
- bool AllEqual() const override { return false; /* otherwise this should be a Splat */ }
- size_t Hash() const override { return hash; }
-
- utils::Result<const Constant*> Convert(ProgramBuilder& builder,
- const sem::Type* target_ty,
- const Source& source) const override {
- // Convert each of the composite element types.
- auto* el_ty = sem::Type::ElementOf(target_ty);
- std::vector<const Constant*> conv_els;
- conv_els.reserve(elements.size());
- for (auto* el : elements) {
- auto conv_el = el->Convert(builder, el_ty, source);
- if (!conv_el) {
- return utils::Failure;
- }
- if (!conv_el.Get()) {
- return nullptr;
- }
- conv_els.emplace_back(conv_el.Get());
- }
- return CreateComposite(builder, target_ty, std::move(conv_els));
- }
-
- size_t CalcHash() {
- auto h = utils::Hash(type, all_zero, any_zero);
- for (auto* el : elements) {
- utils::HashCombine(&h, el->Hash());
- }
- return h;
- }
-
- sem::Type const* const type;
- const std::vector<const Constant*> elements;
- const bool all_zero;
- const bool any_zero;
- const size_t hash;
-};
-
-/// CreateElement constructs and returns an Element<T>.
-template <typename T>
-const Constant* CreateElement(ProgramBuilder& builder, const sem::Type* t, T v) {
- return builder.create<Element<T>>(t, v);
-}
-
-/// ZeroValue returns a Constant for the zero-value of the type `type`.
-const Constant* ZeroValue(ProgramBuilder& builder, const sem::Type* type) {
- return Switch(
- type, //
- [&](const sem::Vector* v) -> const Constant* {
- auto* zero_el = ZeroValue(builder, v->type());
- return builder.create<Splat>(type, zero_el, v->Width());
- },
- [&](const sem::Matrix* m) -> const Constant* {
- auto* zero_el = ZeroValue(builder, m->ColumnType());
- return builder.create<Splat>(type, zero_el, m->columns());
- },
- [&](const sem::Array* a) -> const Constant* {
- if (auto* zero_el = ZeroValue(builder, a->ElemType())) {
- return builder.create<Splat>(type, zero_el, a->Count());
- }
- return nullptr;
- },
- [&](const sem::Struct* s) -> const Constant* {
- std::unordered_map<sem::Type*, const Constant*> zero_by_type;
- std::vector<const Constant*> zeros;
- zeros.reserve(s->Members().size());
- for (auto* member : s->Members()) {
- auto* zero = utils::GetOrCreate(zero_by_type, member->Type(),
- [&] { return ZeroValue(builder, member->Type()); });
- if (!zero) {
- return nullptr;
- }
- zeros.emplace_back(zero);
- }
- if (zero_by_type.size() == 1) {
- // All members were of the same type, so the zero value is the same for all members.
- return builder.create<Splat>(type, zeros[0], s->Members().size());
- }
- return CreateComposite(builder, s, std::move(zeros));
- },
- [&](Default) -> const Constant* {
- return TypeDispatch(type, [&](auto zero) -> const Constant* {
- return CreateElement(builder, type, zero);
- });
- });
-}
-
-/// Equal returns true if the constants `a` and `b` are of the same type and value.
-bool Equal(const sem::Constant* a, const sem::Constant* b) {
- if (a->Hash() != b->Hash()) {
- return false;
- }
- if (a->Type() != b->Type()) {
- return false;
- }
- return Switch(
- a->Type(), //
- [&](const sem::Vector* vec) {
- for (size_t i = 0; i < vec->Width(); i++) {
- if (!Equal(a->Index(i), b->Index(i))) {
- return false;
- }
- }
- return true;
- },
- [&](const sem::Matrix* mat) {
- for (size_t i = 0; i < mat->columns(); i++) {
- if (!Equal(a->Index(i), b->Index(i))) {
- return false;
- }
- }
- return true;
- },
- [&](const sem::Array* arr) {
- for (size_t i = 0; i < arr->Count(); i++) {
- if (!Equal(a->Index(i), b->Index(i))) {
- return false;
- }
- }
- return true;
- },
- [&](Default) { return a->Value() == b->Value(); });
-}
-
-/// CreateComposite is used to construct a constant of a vector, matrix or array type.
-/// CreateComposite examines the element values and will return either a Composite or a Splat,
-/// depending on the element types and values.
-const Constant* CreateComposite(ProgramBuilder& builder,
- const sem::Type* type,
- std::vector<const Constant*> elements) {
- if (elements.size() == 0) {
- return nullptr;
- }
- bool any_zero = false;
- bool all_zero = true;
- bool all_equal = true;
- auto* first = elements.front();
- for (auto* el : elements) {
- if (!el) {
- return nullptr;
- }
- if (!any_zero && el->AnyZero()) {
- any_zero = true;
- }
- if (all_zero && !el->AllZero()) {
- all_zero = false;
- }
- if (all_equal && el != first) {
- if (!Equal(el, first)) {
- all_equal = false;
- }
- }
- }
- if (all_equal) {
- return builder.create<Splat>(type, elements[0], elements.size());
- } else {
- return builder.create<Composite>(type, std::move(elements), all_zero, any_zero);
- }
-}
-
-} // namespace
-
-const sem::Constant* Resolver::EvaluateLiteralValue(const ast::LiteralExpression* literal,
- const sem::Type* type) {
- return Switch(
- literal,
- [&](const ast::BoolLiteralExpression* lit) {
- return CreateElement(*builder_, type, lit->value);
- },
- [&](const ast::IntLiteralExpression* lit) -> const Constant* {
- switch (lit->suffix) {
- case ast::IntLiteralExpression::Suffix::kNone:
- return CreateElement(*builder_, type, AInt(lit->value));
- case ast::IntLiteralExpression::Suffix::kI:
- return CreateElement(*builder_, type, i32(lit->value));
- case ast::IntLiteralExpression::Suffix::kU:
- return CreateElement(*builder_, type, u32(lit->value));
- }
- return nullptr;
- },
- [&](const ast::FloatLiteralExpression* lit) -> const Constant* {
- switch (lit->suffix) {
- case ast::FloatLiteralExpression::Suffix::kNone:
- return CreateElement(*builder_, type, AFloat(lit->value));
- case ast::FloatLiteralExpression::Suffix::kF:
- return CreateElement(*builder_, type, f32(lit->value));
- case ast::FloatLiteralExpression::Suffix::kH:
- return CreateElement(*builder_, type, f16(lit->value));
- }
- return nullptr;
- });
-}
-
-const sem::Constant* Resolver::EvaluateCtorOrConvValue(
- const std::vector<const sem::Expression*>& args,
- const sem::Type* ty) {
- // For zero value init, return 0s
- if (args.empty()) {
- return ZeroValue(*builder_, ty);
- }
-
- if (auto* el_ty = sem::Type::ElementOf(ty); el_ty && args.size() == 1) {
- // Type constructor or conversion that takes a single argument.
- auto& src = args[0]->Declaration()->source;
- auto* arg = static_cast<const Constant*>(args[0]->ConstantValue());
- if (!arg) {
- return nullptr; // Single argument is not constant.
- }
-
- if (ty->is_scalar()) { // Scalar type conversion: i32(x), u32(x), bool(x), etc
- return ConvertValue(arg, el_ty, src).Get();
- }
-
- if (arg->Type() == el_ty) {
- // Argument type matches function type. This is a splat.
- auto splat = [&](size_t n) { return builder_->create<Splat>(ty, arg, n); };
- return Switch(
- ty, //
- [&](const sem::Vector* v) { return splat(v->Width()); },
- [&](const sem::Matrix* m) { return splat(m->columns()); },
- [&](const sem::Array* a) { return splat(a->Count()); });
- }
-
- // Argument type and function type mismatch. This is a type conversion.
- if (auto conv = ConvertValue(arg, ty, src)) {
- return conv.Get();
- }
-
- return nullptr;
- }
-
- // Helper for pushing all the argument constants to `els`.
- auto args_as_constants = [&] {
- return utils::Transform(
- args, [&](auto* expr) { return static_cast<const Constant*>(expr->ConstantValue()); });
- };
-
- // Multiple arguments. Must be a type constructor.
-
- return Switch(
- ty, // What's the target type being constructed?
- [&](const sem::Vector*) -> const Constant* {
- // Vector can be constructed with a mix of scalars / abstract numerics and smaller
- // vectors.
- std::vector<const Constant*> els;
- els.reserve(args.size());
- for (auto* expr : args) {
- auto* arg = static_cast<const Constant*>(expr->ConstantValue());
- if (!arg) {
- return nullptr;
- }
- auto* arg_ty = arg->Type();
- if (auto* arg_vec = arg_ty->As<sem::Vector>()) {
- // Extract out vector elements.
- for (uint32_t i = 0; i < arg_vec->Width(); i++) {
- auto* el = static_cast<const Constant*>(arg->Index(i));
- if (!el) {
- return nullptr;
- }
- els.emplace_back(el);
- }
- } else {
- els.emplace_back(arg);
- }
- }
- return CreateComposite(*builder_, ty, std::move(els));
- },
- [&](const sem::Matrix* m) -> const Constant* {
- // Matrix can be constructed with a set of scalars / abstract numerics, or column
- // vectors.
- if (args.size() == m->columns() * m->rows()) {
- // Matrix built from scalars / abstract numerics
- std::vector<const Constant*> els;
- els.reserve(args.size());
- for (uint32_t c = 0; c < m->columns(); c++) {
- std::vector<const Constant*> column;
- column.reserve(m->rows());
- for (uint32_t r = 0; r < m->rows(); r++) {
- auto* arg =
- static_cast<const Constant*>(args[r + c * m->rows()]->ConstantValue());
- if (!arg) {
- return nullptr;
- }
- column.emplace_back(arg);
- }
- els.push_back(CreateComposite(*builder_, m->ColumnType(), std::move(column)));
- }
- return CreateComposite(*builder_, ty, std::move(els));
- }
- // Matrix built from column vectors
- return CreateComposite(*builder_, ty, args_as_constants());
- },
- [&](const sem::Array*) {
- // Arrays must be constructed using a list of elements
- return CreateComposite(*builder_, ty, args_as_constants());
- },
- [&](const sem::Struct*) {
- // Structures must be constructed using a list of elements
- return CreateComposite(*builder_, ty, args_as_constants());
- });
-}
-
-const sem::Constant* Resolver::EvaluateIndexValue(const sem::Expression* obj_expr,
- const sem::Expression* idx_expr) {
- auto obj_val = obj_expr->ConstantValue();
- if (!obj_val) {
- return {};
- }
-
- auto idx_val = idx_expr->ConstantValue();
- if (!idx_val) {
- return {};
- }
-
- uint32_t el_count = 0;
- sem::Type::ElementOf(obj_val->Type(), &el_count);
-
- AInt idx = idx_val->As<AInt>();
- if (idx < 0 || idx >= el_count) {
- auto clamped = std::min<AInt::type>(std::max<AInt::type>(idx, 0), el_count - 1);
- AddWarning("index " + std::to_string(idx) + " out of bounds [0.." +
- std::to_string(el_count - 1) + "]. Clamping index to " +
- std::to_string(clamped),
- idx_expr->Declaration()->source);
- idx = clamped;
- }
-
- return obj_val->Index(static_cast<size_t>(idx));
-}
-
-const sem::Constant* Resolver::EvaluateMemberAccessValue(const sem::Expression* obj_expr,
- const sem::StructMember* member) {
- auto obj_val = obj_expr->ConstantValue();
- if (!obj_val) {
- return {};
- }
- return obj_val->Index(static_cast<size_t>(member->Index()));
-}
-
-const sem::Constant* Resolver::EvaluateSwizzleValue(const sem::Expression* vec_expr,
- const sem::Type* type,
- const std::vector<uint32_t>& indices) {
- auto* vec_val = vec_expr->ConstantValue();
- if (!vec_val) {
- return nullptr;
- }
- if (indices.size() == 1) {
- return static_cast<const Constant*>(vec_val->Index(static_cast<size_t>(indices[0])));
- } else {
- auto values = utils::Transform(
- indices, [&](uint32_t i) { return static_cast<const Constant*>(vec_val->Index(i)); });
- return CreateComposite(*builder_, type, std::move(values));
- }
-}
-
-const sem::Constant* Resolver::EvaluateBitcastValue(const sem::Expression*, const sem::Type*) {
- // TODO(crbug.com/tint/1581): Implement @const intrinsics
- return nullptr;
-}
-
-const sem::Constant* Resolver::EvaluateBinaryValue(const sem::Expression*,
- const sem::Expression*,
- const IntrinsicTable::BinaryOperator&) {
- // TODO(crbug.com/tint/1581): Implement @const intrinsics
- return nullptr;
-}
-
-const sem::Constant* Resolver::EvaluateUnaryValue(const sem::Expression*,
- const IntrinsicTable::UnaryOperator&) {
- // TODO(crbug.com/tint/1581): Implement @const intrinsics
- return nullptr;
-}
-
-utils::Result<const sem::Constant*> Resolver::ConvertValue(const sem::Constant* value,
- const sem::Type* target_ty,
- const Source& source) {
- if (value->Type() == target_ty) {
- return value;
- }
- auto conv = static_cast<const Constant*>(value)->Convert(*builder_, target_ty, source);
- if (!conv) {
- return utils::Failure;
- }
- return conv.Get();
-}
-
-} // namespace tint::resolver
diff --git a/src/tint/resolver/type_constructor_validation_test.cc b/src/tint/resolver/type_constructor_validation_test.cc
index 1c857cd..41cc698 100644
--- a/src/tint/resolver/type_constructor_validation_test.cc
+++ b/src/tint/resolver/type_constructor_validation_test.cc
@@ -276,10 +276,6 @@
ParamsFor<vec3<f32>, f32>(Kind::Construct), //
ParamsFor<vec3<f16>, f16>(Kind::Construct), //
- ParamsFor<mat3x3<f32>, f32>(Kind::Construct), //
- ParamsFor<mat2x3<f32>, f32>(Kind::Construct), //
- ParamsFor<mat3x2<f32>, f32>(Kind::Construct), //
-
// Conversion
ParamsFor<bool, u32>(Kind::Conversion), //
ParamsFor<bool, i32>(Kind::Conversion), //
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index d99d35b..0b8fb8c 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -533,14 +533,46 @@
return true;
}
+bool Validator::LocalVariable(const sem::Variable* v) const {
+ auto* decl = v->Declaration();
+ return Switch(
+ decl, //
+ [&](const ast::Var* var) {
+ if (IsValidationEnabled(var->attributes,
+ ast::DisabledValidation::kIgnoreStorageClass)) {
+ if (!v->Type()->UnwrapRef()->IsConstructible()) {
+ AddError("function-scope 'var' must have a constructible type",
+ var->type ? var->type->source : var->source);
+ return false;
+ }
+ }
+ return Var(v);
+ }, //
+ [&](const ast::Let*) { return Let(v); }, //
+ [&](const ast::Const*) { return true; }, //
+ [&](Default) {
+ TINT_ICE(Resolver, diagnostics_)
+ << "Validator::Variable() called with a unknown variable type: "
+ << decl->TypeInfo().name;
+ return false;
+ });
+}
+
bool Validator::GlobalVariable(
const sem::GlobalVariable* global,
- std::unordered_map<uint32_t, const sem::Variable*> constant_ids,
- std::unordered_map<const sem::Type*, const Source&> atomic_composite_info) const {
+ const std::unordered_map<uint32_t, const sem::Variable*>& constant_ids,
+ const std::unordered_map<const sem::Type*, const Source&>& atomic_composite_info) const {
auto* decl = global->Declaration();
bool ok = Switch(
decl, //
[&](const ast::Var* var) {
+ if (auto* init = global->Constructor();
+ init && init->Stage() > sem::EvaluationStage::kOverride) {
+ AddError("module-scope 'var' initializer must be a constant or override expression",
+ init->Declaration()->source);
+ return false;
+ }
+
if (global->StorageClass() == ast::StorageClass::kNone) {
AddError("module-scope 'var' declaration must have a storage class", decl->source);
return false;
@@ -583,41 +615,17 @@
return false;
}
- return Var(global);
- },
- [&](const ast::Let*) {
- if (!decl->attributes.empty()) {
- AddError("attribute is not valid for module-scope 'let' declaration",
- decl->attributes[0]->source);
+ auto name = symbols_.NameFor(var->symbol);
+ if (sem::ParseBuiltinType(name) != sem::BuiltinType::kNone) {
+ AddError(
+ "'" + name + "' is a builtin and cannot be redeclared as a module-scope 'var'",
+ var->source);
return false;
}
- return Let(global);
+
+ return Var(global);
},
- [&](const ast::Override*) {
- for (auto* attr : decl->attributes) {
- if (auto* id_attr = attr->As<ast::IdAttribute>()) {
- uint32_t id = id_attr->value;
- auto it = constant_ids.find(id);
- if (it != constant_ids.end() && it->second != global) {
- AddError("pipeline constant IDs must be unique", attr->source);
- AddNote("a pipeline constant with an ID of " + std::to_string(id) +
- " was previously declared here:",
- ast::GetAttribute<ast::IdAttribute>(
- it->second->Declaration()->attributes)
- ->source);
- return false;
- }
- if (id > 65535) {
- AddError("pipeline constant IDs must be between 0 and 65535", attr->source);
- return false;
- }
- } else {
- AddError("attribute is not valid for 'override' declaration", attr->source);
- return false;
- }
- }
- return Override(global);
- },
+ [&](const ast::Override*) { return Override(global, constant_ids); },
[&](const ast::Const*) {
if (!decl->attributes.empty()) {
AddError("attribute is not valid for module-scope 'const' declaration",
@@ -710,49 +718,15 @@
return true;
}
-bool Validator::Variable(const sem::Variable* v) const {
- auto* decl = v->Declaration();
- return Switch(
- decl, //
- [&](const ast::Var*) { return Var(v); }, //
- [&](const ast::Let*) { return Let(v); }, //
- [&](const ast::Override*) { return Override(v); }, //
- [&](const ast::Const*) { return true; }, //
- [&](Default) {
- TINT_ICE(Resolver, diagnostics_)
- << "Validator::Variable() called with a unknown variable type: "
- << decl->TypeInfo().name;
- return false;
- });
-}
-
bool Validator::Var(const sem::Variable* v) const {
auto* var = v->Declaration()->As<ast::Var>();
auto* storage_ty = v->Type()->UnwrapRef();
- if (v->Is<sem::GlobalVariable>()) {
- auto name = symbols_.NameFor(var->symbol);
- if (sem::ParseBuiltinType(name) != sem::BuiltinType::kNone) {
- AddError("'" + name + "' is a builtin and cannot be redeclared as a module-scope 'var'",
- var->source);
- return false;
- }
- }
-
if (!IsStorable(storage_ty)) {
AddError(sem_.TypeNameOf(storage_ty) + " cannot be used as the type of a var", var->source);
return false;
}
- if (v->Is<sem::LocalVariable>() &&
- IsValidationEnabled(var->attributes, ast::DisabledValidation::kIgnoreStorageClass)) {
- if (!v->Type()->UnwrapRef()->IsConstructible()) {
- AddError("function-scope 'var' must have a constructible type",
- var->type ? var->type->source : var->source);
- return false;
- }
- }
-
if (storage_ty->is_handle() && var->declared_storage_class != ast::StorageClass::kNone) {
// https://gpuweb.github.io/gpuweb/wgsl/#module-scope-variables
// If the store type is a texture type or a sampler type, then the
@@ -777,15 +751,6 @@
auto* decl = v->Declaration();
auto* storage_ty = v->Type()->UnwrapRef();
- if (v->Is<sem::GlobalVariable>()) {
- auto name = symbols_.NameFor(decl->symbol);
- if (sem::ParseBuiltinType(name) != sem::BuiltinType::kNone) {
- AddError("'" + name + "' is a builtin and cannot be redeclared as a 'let'",
- decl->source);
- return false;
- }
- }
-
if (!(storage_ty->IsConstructible() || storage_ty->Is<sem::Pointer>())) {
AddError(sem_.TypeNameOf(storage_ty) + " cannot be used as the type of a 'let'",
decl->source);
@@ -794,10 +759,40 @@
return true;
}
-bool Validator::Override(const sem::Variable* v) const {
+bool Validator::Override(
+ const sem::Variable* v,
+ const std::unordered_map<uint32_t, const sem::Variable*>& constant_ids) const {
auto* decl = v->Declaration();
auto* storage_ty = v->Type()->UnwrapRef();
+ if (auto* init = v->Constructor(); init && init->Stage() > sem::EvaluationStage::kOverride) {
+ AddError("'override' initializer must be an override expression",
+ init->Declaration()->source);
+ return false;
+ }
+
+ for (auto* attr : decl->attributes) {
+ if (auto* id_attr = attr->As<ast::IdAttribute>()) {
+ uint32_t id = id_attr->value;
+ auto it = constant_ids.find(id);
+ if (it != constant_ids.end() && it->second != v) {
+ AddError("pipeline constant IDs must be unique", attr->source);
+ AddNote("a pipeline constant with an ID of " + std::to_string(id) +
+ " was previously declared here:",
+ ast::GetAttribute<ast::IdAttribute>(it->second->Declaration()->attributes)
+ ->source);
+ return false;
+ }
+ if (id > 65535) {
+ AddError("pipeline constant IDs must be between 0 and 65535", attr->source);
+ return false;
+ }
+ } else {
+ AddError("attribute is not valid for 'override' declaration", attr->source);
+ return false;
+ }
+ }
+
auto name = symbols_.NameFor(decl->symbol);
if (sem::ParseBuiltinType(name) != sem::BuiltinType::kNone) {
AddError("'" + name + "' is a builtin and cannot be redeclared as a 'override'",
diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h
index a591589..ed20af0 100644
--- a/src/tint/resolver/validator.h
+++ b/src/tint/resolver/validator.h
@@ -239,8 +239,8 @@
/// @returns true on success, false otherwise
bool GlobalVariable(
const sem::GlobalVariable* var,
- std::unordered_map<uint32_t, const sem::Variable*> constant_ids,
- std::unordered_map<const sem::Type*, const Source&> atomic_composite_info) const;
+ const std::unordered_map<uint32_t, const sem::Variable*>& constant_ids,
+ const std::unordered_map<const sem::Type*, const Source&>& atomic_composite_info) const;
/// Validates an if statement
/// @param stmt the statement to validate
@@ -264,6 +264,11 @@
/// @returns true on success, false otherwise.
bool BuiltinCall(const sem::Call* call) const;
+ /// Validates a local variable
+ /// @param v the variable to validate
+ /// @returns true on success, false otherwise.
+ bool LocalVariable(const sem::Variable* v) const;
+
/// Validates a location attribute
/// @param location the location attribute to validate
/// @param type the variable type
@@ -354,11 +359,6 @@
/// @returns true on success, false otherwise
bool SwitchStatement(const ast::SwitchStatement* s);
- /// Validates a variable
- /// @param v the variable to validate
- /// @returns true on success, false otherwise.
- bool Variable(const sem::Variable* v) const;
-
/// Validates a 'var' variable declaration
/// @param v the variable to validate
/// @returns true on success, false otherwise.
@@ -371,8 +371,10 @@
/// Validates a 'override' variable declaration
/// @param v the variable to validate
+ /// @param constant_ids the set of constant ids in the module
/// @returns true on success, false otherwise.
- bool Override(const sem::Variable* v) const;
+ bool Override(const sem::Variable* v,
+ const std::unordered_map<uint32_t, const sem::Variable*>& constant_ids) const;
/// Validates a 'const' variable declaration
/// @param v the variable to validate
diff --git a/src/tint/resolver/variable_validation_test.cc b/src/tint/resolver/variable_validation_test.cc
index b538db0..5625f00 100644
--- a/src/tint/resolver/variable_validation_test.cc
+++ b/src/tint/resolver/variable_validation_test.cc
@@ -59,18 +59,16 @@
EXPECT_EQ(r()->error(), "12:34 error: override declaration requires a type or initializer");
}
-TEST_F(ResolverVariableValidationTest, VarTypeNotStorable) {
+TEST_F(ResolverVariableValidationTest, VarTypeNotConstructible) {
// var i : i32;
// var p : pointer<function, i32> = &v;
auto* i = Var("i", ty.i32(), ast::StorageClass::kNone);
- auto* p = Var(Source{{56, 78}}, "a", ty.pointer<i32>(ast::StorageClass::kFunction),
+ auto* p = Var("a", ty.pointer<i32>(Source{{56, 78}}, ast::StorageClass::kFunction),
ast::StorageClass::kNone, AddressOf(Source{{12, 34}}, "i"));
WrapInFunction(i, p);
EXPECT_FALSE(r()->Resolve());
- EXPECT_EQ(r()->error(),
- "56:78 error: ptr<function, i32, read_write> cannot be used as the "
- "type of a var");
+ EXPECT_EQ(r()->error(), "56:78 error: function-scope 'var' must have a constructible type");
}
TEST_F(ResolverVariableValidationTest, LetTypeNotConstructible) {
diff --git a/src/tint/sem/builtin.cc b/src/tint/sem/builtin.cc
index bb2878b..c688c4c 100644
--- a/src/tint/sem/builtin.cc
+++ b/src/tint/sem/builtin.cc
@@ -90,9 +90,10 @@
Builtin::Builtin(BuiltinType type,
const sem::Type* return_type,
std::vector<Parameter*> parameters,
+ EvaluationStage eval_stage,
PipelineStageSet supported_stages,
bool is_deprecated)
- : Base(return_type, utils::ToConstPtrVec(parameters)),
+ : Base(return_type, utils::ToConstPtrVec(parameters), eval_stage),
type_(type),
supported_stages_(supported_stages),
is_deprecated_(is_deprecated) {
diff --git a/src/tint/sem/builtin.h b/src/tint/sem/builtin.h
index 1dc61ad..783e6ca 100644
--- a/src/tint/sem/builtin.h
+++ b/src/tint/sem/builtin.h
@@ -83,6 +83,7 @@
/// @param type the builtin type
/// @param return_type the return type for the builtin call
/// @param parameters the parameters for the builtin overload
+ /// @param eval_stage the earliest evaluation stage for a call to the builtin
/// @param supported_stages the pipeline stages that this builtin can be
/// used in
/// @param is_deprecated true if the particular overload is considered
@@ -90,6 +91,7 @@
Builtin(BuiltinType type,
const sem::Type* return_type,
std::vector<Parameter*> parameters,
+ EvaluationStage eval_stage,
PipelineStageSet supported_stages,
bool is_deprecated);
diff --git a/src/tint/sem/call.cc b/src/tint/sem/call.cc
index bfce3b1..a20649d 100644
--- a/src/tint/sem/call.cc
+++ b/src/tint/sem/call.cc
@@ -23,13 +23,17 @@
Call::Call(const ast::CallExpression* declaration,
const CallTarget* target,
+ EvaluationStage stage,
std::vector<const sem::Expression*> arguments,
const Statement* statement,
const Constant* constant,
bool has_side_effects)
- : Base(declaration, target->ReturnType(), statement, constant, has_side_effects),
+ : Base(declaration, target->ReturnType(), stage, statement, constant, has_side_effects),
target_(target),
- arguments_(std::move(arguments)) {}
+ arguments_(std::move(arguments)) {
+ // Check that the stage is no earlier than the target supports
+ TINT_ASSERT(Semantic, target->Stage() <= stage);
+}
Call::~Call() = default;
diff --git a/src/tint/sem/call.h b/src/tint/sem/call.h
index 1955bf9..2d82306 100644
--- a/src/tint/sem/call.h
+++ b/src/tint/sem/call.h
@@ -30,12 +30,14 @@
/// Constructor
/// @param declaration the AST node
/// @param target the call target
+ /// @param stage the earliest evaluation stage for the expression
/// @param arguments the call arguments
/// @param statement the statement that owns this expression
/// @param constant the constant value of this expression
/// @param has_side_effects whether this expression may have side effects
Call(const ast::CallExpression* declaration,
const CallTarget* target,
+ EvaluationStage stage,
std::vector<const sem::Expression*> arguments,
const Statement* statement,
const Constant* constant,
diff --git a/src/tint/sem/call_target.cc b/src/tint/sem/call_target.cc
index 67bde0e..f8bcdd8 100644
--- a/src/tint/sem/call_target.cc
+++ b/src/tint/sem/call_target.cc
@@ -21,8 +21,10 @@
namespace tint::sem {
-CallTarget::CallTarget(const sem::Type* return_type, const ParameterList& parameters)
- : signature_{return_type, parameters} {
+CallTarget::CallTarget(const sem::Type* return_type,
+ const ParameterList& parameters,
+ EvaluationStage stage)
+ : signature_{return_type, parameters}, stage_(stage) {
TINT_ASSERT(Semantic, return_type);
}
diff --git a/src/tint/sem/call_target.h b/src/tint/sem/call_target.h
index 64716b2..be1b96a 100644
--- a/src/tint/sem/call_target.h
+++ b/src/tint/sem/call_target.h
@@ -63,9 +63,12 @@
class CallTarget : public Castable<CallTarget, Node> {
public:
/// Constructor
+ /// @param stage the earliest evaluation stage for a call to this target
/// @param return_type the return type of the call target
/// @param parameters the parameters for the call target
- CallTarget(const sem::Type* return_type, const ParameterList& parameters);
+ CallTarget(const sem::Type* return_type,
+ const ParameterList& parameters,
+ EvaluationStage stage);
/// Copy constructor
CallTarget(const CallTarget&);
@@ -82,8 +85,12 @@
/// @return the signature of the call target
const CallTargetSignature& Signature() const { return signature_; }
+ /// @return the earliest evaluation stage for a call to this target
+ EvaluationStage Stage() const { return stage_; }
+
private:
CallTargetSignature signature_;
+ EvaluationStage stage_;
};
} // namespace tint::sem
diff --git a/src/tint/sem/evaluation_stage.h b/src/tint/sem/evaluation_stage.h
new file mode 100644
index 0000000..b5e554d
--- /dev/null
+++ b/src/tint/sem/evaluation_stage.h
@@ -0,0 +1,60 @@
+// Copyright 2022 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.
+
+#ifndef SRC_TINT_SEM_EVALUATION_STAGE_H_
+#define SRC_TINT_SEM_EVALUATION_STAGE_H_
+
+#include <algorithm>
+#include <initializer_list>
+
+namespace tint::sem {
+
+/// The earliest point in time that an expression can be evaluated
+enum class EvaluationStage {
+ /// Expression can be evaluated at shader creation time
+ kConstant,
+ /// Expression can be evaluated at pipeline creation time
+ kOverride,
+ /// Expression can be evaluated at runtime
+ kRuntime,
+};
+
+/// @returns true if stage `a` comes earlier than stage `b`
+inline bool operator<(EvaluationStage a, EvaluationStage b) {
+ return static_cast<int>(a) < static_cast<int>(b);
+}
+
+/// @returns true if stage `a` comes later than stage `b`
+inline bool operator>(EvaluationStage a, EvaluationStage b) {
+ return static_cast<int>(a) > static_cast<int>(b);
+}
+
+/// @param stages a list of EvaluationStage.
+/// @returns the earliest stage supported by all the provided stages
+inline EvaluationStage EarliestStage(std::initializer_list<EvaluationStage> stages) {
+ auto earliest = EvaluationStage::kConstant;
+ for (auto stage : stages) {
+ earliest = std::max(stage, earliest);
+ }
+ return static_cast<EvaluationStage>(earliest);
+}
+
+template <typename... ARGS>
+inline EvaluationStage EarliestStage(ARGS... args) {
+ return EarliestStage({args...});
+}
+
+} // namespace tint::sem
+
+#endif // SRC_TINT_SEM_EVALUATION_STAGE_H_
diff --git a/src/tint/sem/expression.cc b/src/tint/sem/expression.cc
index 4415db5..cdaa2bc 100644
--- a/src/tint/sem/expression.cc
+++ b/src/tint/sem/expression.cc
@@ -24,6 +24,7 @@
Expression::Expression(const ast::Expression* declaration,
const sem::Type* type,
+ EvaluationStage stage,
const Statement* statement,
const Constant* constant,
bool has_side_effects,
@@ -31,10 +32,12 @@
: declaration_(declaration),
source_variable_(source_var),
type_(type),
+ stage_(stage),
statement_(statement),
constant_(std::move(constant)),
has_side_effects_(has_side_effects) {
TINT_ASSERT(Semantic, type_);
+ TINT_ASSERT(Semantic, (constant != nullptr) == (stage == EvaluationStage::kConstant));
}
Expression::~Expression() = default;
diff --git a/src/tint/sem/expression.h b/src/tint/sem/expression.h
index 45a67ca..5942a71 100644
--- a/src/tint/sem/expression.h
+++ b/src/tint/sem/expression.h
@@ -18,6 +18,7 @@
#include "src/tint/ast/expression.h"
#include "src/tint/sem/behavior.h"
#include "src/tint/sem/constant.h"
+#include "src/tint/sem/evaluation_stage.h"
#include "src/tint/sem/node.h"
// Forward declarations
@@ -28,18 +29,21 @@
} // namespace tint::sem
namespace tint::sem {
+
/// Expression holds the semantic information for expression nodes.
class Expression : public Castable<Expression, Node> {
public:
/// Constructor
/// @param declaration the AST node
/// @param type the resolved type of the expression
+ /// @param stage the earliest evaluation stage for the expression
/// @param statement the statement that owns this expression
/// @param constant the constant value of the expression. May be null
/// @param has_side_effects true if this expression may have side-effects
/// @param source_var the (optional) source variable for this expression
Expression(const ast::Expression* declaration,
const sem::Type* type,
+ EvaluationStage stage,
const Statement* statement,
const Constant* constant,
bool has_side_effects,
@@ -54,6 +58,9 @@
/// @return the resolved type of the expression
const sem::Type* Type() const { return type_; }
+ /// @return the earliest evaluation stage for the expression
+ EvaluationStage Stage() const { return stage_; }
+
/// @return the statement that owns this expression
const Statement* Stmt() const { return statement_; }
@@ -87,6 +94,7 @@
private:
const sem::Type* const type_;
+ const EvaluationStage stage_;
const Statement* const statement_;
const Constant* const constant_;
sem::Behaviors behaviors_{sem::Behavior::kNext};
diff --git a/src/tint/sem/expression_test.cc b/src/tint/sem/expression_test.cc
index cc4bf0e..63e01fb 100644
--- a/src/tint/sem/expression_test.cc
+++ b/src/tint/sem/expression_test.cc
@@ -43,7 +43,8 @@
TEST_F(ExpressionTest, UnwrapMaterialize) {
MockConstant c(create<I32>());
- auto* a = create<Expression>(/* declaration */ nullptr, create<I32>(), /* statement */ nullptr,
+ auto* a = create<Expression>(/* declaration */ nullptr, create<I32>(),
+ sem::EvaluationStage::kRuntime, /* statement */ nullptr,
/* constant_value */ nullptr,
/* has_side_effects */ false, /* source_var */ nullptr);
auto* b = create<Materialize>(a, /* statement */ nullptr, &c);
diff --git a/src/tint/sem/function.cc b/src/tint/sem/function.cc
index cd34eb7..dcc80b0 100644
--- a/src/tint/sem/function.cc
+++ b/src/tint/sem/function.cc
@@ -30,7 +30,7 @@
Function::Function(const ast::Function* declaration,
Type* return_type,
std::vector<Parameter*> parameters)
- : Base(return_type, utils::ToConstPtrVec(parameters)),
+ : Base(return_type, utils::ToConstPtrVec(parameters), EvaluationStage::kRuntime),
declaration_(declaration),
workgroup_size_{WorkgroupDimension{1}, WorkgroupDimension{1}, WorkgroupDimension{1}} {
for (auto* parameter : parameters) {
diff --git a/src/tint/sem/index_accessor_expression.cc b/src/tint/sem/index_accessor_expression.cc
index cd74201..70d1d5f 100644
--- a/src/tint/sem/index_accessor_expression.cc
+++ b/src/tint/sem/index_accessor_expression.cc
@@ -24,13 +24,14 @@
IndexAccessorExpression::IndexAccessorExpression(const ast::IndexAccessorExpression* declaration,
const sem::Type* type,
+ EvaluationStage stage,
const Expression* object,
const Expression* index,
const Statement* statement,
const Constant* constant,
bool has_side_effects,
const Variable* source_var /* = nullptr */)
- : Base(declaration, type, statement, constant, has_side_effects, source_var),
+ : Base(declaration, type, stage, statement, constant, has_side_effects, source_var),
object_(object),
index_(index) {}
diff --git a/src/tint/sem/index_accessor_expression.h b/src/tint/sem/index_accessor_expression.h
index 3ba10ea..ea93df7 100644
--- a/src/tint/sem/index_accessor_expression.h
+++ b/src/tint/sem/index_accessor_expression.h
@@ -32,6 +32,7 @@
/// Constructor
/// @param declaration the AST node
/// @param type the resolved type of the expression
+ /// @param stage the earliest evaluation stage for the expression
/// @param object the object expression that is being indexed
/// @param index the index expression
/// @param statement the statement that owns this expression
@@ -40,6 +41,7 @@
/// @param source_var the (optional) source variable for this expression
IndexAccessorExpression(const ast::IndexAccessorExpression* declaration,
const sem::Type* type,
+ EvaluationStage stage,
const Expression* object,
const Expression* index,
const Statement* statement,
diff --git a/src/tint/sem/info.h b/src/tint/sem/info.h
index 41321cf..d9fb7b2 100644
--- a/src/tint/sem/info.h
+++ b/src/tint/sem/info.h
@@ -37,10 +37,9 @@
/// Resolves to the return type of the Get() method given the desired sementic
/// type and AST type.
- template <typename SEM, typename AST_OR_TYPE>
- using GetResultType = std::conditional_t<std::is_same<SEM, InferFromAST>::value,
- SemanticNodeTypeFor<AST_OR_TYPE>,
- SEM>;
+ template <typename SEM, typename AST>
+ using GetResultType =
+ std::conditional_t<std::is_same<SEM, InferFromAST>::value, SemanticNodeTypeFor<AST>, SEM>;
/// Constructor
Info();
@@ -56,36 +55,36 @@
/// @return this Program
Info& operator=(Info&& rhs);
- /// Get looks up the semantic information for the AST or type node `node`.
- /// @param node the AST or type node
+ /// Get looks up the semantic information for the AST node `node`.
+ /// @param ast_node the AST node
/// @returns a pointer to the semantic node if found, otherwise nullptr
template <typename SEM = InferFromAST,
- typename AST_OR_TYPE = CastableBase,
- typename RESULT = GetResultType<SEM, AST_OR_TYPE>>
- const RESULT* Get(const AST_OR_TYPE* node) const {
- auto it = map_.find(node);
+ typename AST = CastableBase,
+ typename RESULT = GetResultType<SEM, AST>>
+ const RESULT* Get(const AST* ast_node) const {
+ auto it = map_.find(ast_node);
if (it == map_.end()) {
return nullptr;
}
return As<RESULT>(it->second);
}
- /// Add registers the semantic node `sem_node` for the AST or type node `node`.
- /// @param node the AST or type node
+ /// Add registers the semantic node `sem_node` for the AST node `node`.
+ /// @param ast_node the AST node
/// @param sem_node the semantic node
- template <typename AST_OR_TYPE>
- void Add(const AST_OR_TYPE* node, const SemanticNodeTypeFor<AST_OR_TYPE>* sem_node) {
+ template <typename AST>
+ void Add(const AST* ast_node, const SemanticNodeTypeFor<AST>* sem_node) {
// Check there's no semantic info already existing for the node
- TINT_ASSERT(Semantic, Get(node) == nullptr);
- map_.emplace(node, sem_node);
+ TINT_ASSERT(Semantic, Get(ast_node) == nullptr);
+ map_.emplace(ast_node, sem_node);
}
- /// Replace replaces any existing semantic node `sem_node` for the AST or type node `node`.
- /// @param node the AST or type node
+ /// Replace replaces any existing semantic node `sem_node` for the AST node `node`.
+ /// @param ast_node the AST node
/// @param sem_node the new semantic node
- template <typename AST_OR_TYPE>
- void Replace(const AST_OR_TYPE* node, const SemanticNodeTypeFor<AST_OR_TYPE>* sem_node) {
- map_[node] = sem_node;
+ template <typename AST>
+ void Replace(const AST* ast_node, const SemanticNodeTypeFor<AST>* sem_node) {
+ map_[ast_node] = sem_node;
}
/// Wrap returns a new Info created with the contents of `inner`.
@@ -110,9 +109,8 @@
const sem::Module* Module() const { return module_; }
private:
- // TODO(crbug.com/tint/724): Once finished, this map should be:
- // std::unordered_map<const ast::Node*, const sem::Node*>
- std::unordered_map<const CastableBase*, const CastableBase*> map_;
+ // The map of AST node to semantic node
+ std::unordered_map<const ast::Node*, const sem::Node*> map_;
// The semantic module
sem::Module* module_ = nullptr;
};
diff --git a/src/tint/sem/materialize.cc b/src/tint/sem/materialize.cc
index 739b0ce..15c31ae 100644
--- a/src/tint/sem/materialize.cc
+++ b/src/tint/sem/materialize.cc
@@ -22,6 +22,7 @@
const Constant* constant)
: Base(/* declaration */ expr->Declaration(),
/* type */ constant->Type(),
+ /* stage */ EvaluationStage::kConstant, // Abstract can only be const-expr
/* statement */ statement,
/* constant */ constant,
/* has_side_effects */ false,
diff --git a/src/tint/sem/member_accessor_expression.cc b/src/tint/sem/member_accessor_expression.cc
index 7c31b0e..74b4833 100644
--- a/src/tint/sem/member_accessor_expression.cc
+++ b/src/tint/sem/member_accessor_expression.cc
@@ -25,12 +25,14 @@
MemberAccessorExpression::MemberAccessorExpression(const ast::MemberAccessorExpression* declaration,
const sem::Type* type,
+ EvaluationStage stage,
const Statement* statement,
const Constant* constant,
const Expression* object,
bool has_side_effects,
const Variable* source_var /* = nullptr */)
- : Base(declaration, type, statement, constant, has_side_effects, source_var), object_(object) {}
+ : Base(declaration, type, stage, statement, constant, has_side_effects, source_var),
+ object_(object) {}
MemberAccessorExpression::~MemberAccessorExpression() = default;
@@ -42,7 +44,14 @@
const StructMember* member,
bool has_side_effects,
const Variable* source_var /* = nullptr */)
- : Base(declaration, type, statement, constant, object, has_side_effects, source_var),
+ : Base(declaration,
+ type,
+ object->Stage(),
+ statement,
+ constant,
+ object,
+ has_side_effects,
+ source_var),
member_(member) {}
StructMemberAccess::~StructMemberAccess() = default;
@@ -55,7 +64,14 @@
std::vector<uint32_t> indices,
bool has_side_effects,
const Variable* source_var /* = nullptr */)
- : Base(declaration, type, statement, constant, object, has_side_effects, source_var),
+ : Base(declaration,
+ type,
+ object->Stage(),
+ statement,
+ constant,
+ object,
+ has_side_effects,
+ source_var),
indices_(std::move(indices)) {}
Swizzle::~Swizzle() = default;
diff --git a/src/tint/sem/member_accessor_expression.h b/src/tint/sem/member_accessor_expression.h
index d8484a8..43e1466 100644
--- a/src/tint/sem/member_accessor_expression.h
+++ b/src/tint/sem/member_accessor_expression.h
@@ -37,6 +37,7 @@
/// Constructor
/// @param declaration the AST node
/// @param type the resolved type of the expression
+ /// @param stage the earliest evaluation stage for the expression
/// @param statement the statement that owns this expression
/// @param constant the constant value of the expression. May be null.
/// @param object the object that holds the member being accessed
@@ -44,6 +45,7 @@
/// @param source_var the (optional) source variable for this expression
MemberAccessorExpression(const ast::MemberAccessorExpression* declaration,
const sem::Type* type,
+ EvaluationStage stage,
const Statement* statement,
const Constant* constant,
const Expression* object,
diff --git a/src/tint/sem/type_constructor.cc b/src/tint/sem/type_constructor.cc
index 34f6e2a..d85e1be 100644
--- a/src/tint/sem/type_constructor.cc
+++ b/src/tint/sem/type_constructor.cc
@@ -18,8 +18,10 @@
namespace tint::sem {
-TypeConstructor::TypeConstructor(const sem::Type* type, const ParameterList& parameters)
- : Base(type, parameters) {}
+TypeConstructor::TypeConstructor(const sem::Type* type,
+ const ParameterList& parameters,
+ EvaluationStage stage)
+ : Base(type, parameters, stage) {}
TypeConstructor::~TypeConstructor() = default;
diff --git a/src/tint/sem/type_constructor.h b/src/tint/sem/type_constructor.h
index f3d4221..74b7858 100644
--- a/src/tint/sem/type_constructor.h
+++ b/src/tint/sem/type_constructor.h
@@ -25,7 +25,8 @@
/// Constructor
/// @param type the type that's being constructed
/// @param parameters the type constructor parameters
- TypeConstructor(const sem::Type* type, const ParameterList& parameters);
+ /// @param stage the earliest evaluation stage for the expression
+ TypeConstructor(const sem::Type* type, const ParameterList& parameters, EvaluationStage stage);
/// Destructor
~TypeConstructor() override;
diff --git a/src/tint/sem/type_conversion.cc b/src/tint/sem/type_conversion.cc
index 5da2928..262e3a0 100644
--- a/src/tint/sem/type_conversion.cc
+++ b/src/tint/sem/type_conversion.cc
@@ -18,8 +18,10 @@
namespace tint::sem {
-TypeConversion::TypeConversion(const sem::Type* type, const sem::Parameter* parameter)
- : Base(type, ParameterList{parameter}) {}
+TypeConversion::TypeConversion(const sem::Type* type,
+ const sem::Parameter* parameter,
+ EvaluationStage stage)
+ : Base(type, ParameterList{parameter}, stage) {}
TypeConversion::~TypeConversion() = default;
diff --git a/src/tint/sem/type_conversion.h b/src/tint/sem/type_conversion.h
index e400565..5584b36 100644
--- a/src/tint/sem/type_conversion.h
+++ b/src/tint/sem/type_conversion.h
@@ -25,7 +25,8 @@
/// Constructor
/// @param type the target type of the cast
/// @param parameter the type cast parameter
- TypeConversion(const sem::Type* type, const sem::Parameter* parameter);
+ /// @param stage the earliest evaluation stage for the expression
+ TypeConversion(const sem::Type* type, const sem::Parameter* parameter, EvaluationStage stage);
/// Destructor
~TypeConversion() override;
diff --git a/src/tint/sem/variable.cc b/src/tint/sem/variable.cc
index 3849807..28a373b 100644
--- a/src/tint/sem/variable.cc
+++ b/src/tint/sem/variable.cc
@@ -28,14 +28,15 @@
TINT_INSTANTIATE_TYPEINFO(tint::sem::VariableUser);
namespace tint::sem {
-
Variable::Variable(const ast::Variable* declaration,
const sem::Type* type,
+ EvaluationStage stage,
ast::StorageClass storage_class,
ast::Access access,
const Constant* constant_value)
: declaration_(declaration),
type_(type),
+ stage_(stage),
storage_class_(storage_class),
access_(access),
constant_value_(constant_value) {}
@@ -44,21 +45,24 @@
LocalVariable::LocalVariable(const ast::Variable* declaration,
const sem::Type* type,
+ EvaluationStage stage,
ast::StorageClass storage_class,
ast::Access access,
const sem::Statement* statement,
const Constant* constant_value)
- : Base(declaration, type, storage_class, access, constant_value), statement_(statement) {}
+ : Base(declaration, type, stage, storage_class, access, constant_value),
+ statement_(statement) {}
LocalVariable::~LocalVariable() = default;
GlobalVariable::GlobalVariable(const ast::Variable* declaration,
const sem::Type* type,
+ EvaluationStage stage,
ast::StorageClass storage_class,
ast::Access access,
const Constant* constant_value,
sem::BindingPoint binding_point)
- : Base(declaration, type, storage_class, access, constant_value),
+ : Base(declaration, type, stage, storage_class, access, constant_value),
binding_point_(binding_point) {}
GlobalVariable::~GlobalVariable() = default;
@@ -69,7 +73,9 @@
ast::StorageClass storage_class,
ast::Access access,
const ParameterUsage usage /* = ParameterUsage::kNone */)
- : Base(declaration, type, storage_class, access, nullptr), index_(index), usage_(usage) {}
+ : Base(declaration, type, EvaluationStage::kRuntime, storage_class, access, nullptr),
+ index_(index),
+ usage_(usage) {}
Parameter::~Parameter() = default;
@@ -78,6 +84,7 @@
sem::Variable* variable)
: Base(declaration,
variable->Type(),
+ variable->Stage(),
statement,
variable->ConstantValue(),
/* has_side_effects */ false),
diff --git a/src/tint/sem/variable.h b/src/tint/sem/variable.h
index e5a5cec..fe54f50 100644
--- a/src/tint/sem/variable.h
+++ b/src/tint/sem/variable.h
@@ -45,11 +45,13 @@
/// Constructor
/// @param declaration the AST declaration node
/// @param type the variable type
+ /// @param stage the evaluation stage for an expression of this variable type
/// @param storage_class the variable storage class
/// @param access the variable access control type
/// @param constant_value the constant value for the variable. May be null
Variable(const ast::Variable* declaration,
const sem::Type* type,
+ EvaluationStage stage,
ast::StorageClass storage_class,
ast::Access access,
const Constant* constant_value);
@@ -63,6 +65,9 @@
/// @returns the canonical type for the variable
const sem::Type* Type() const { return type_; }
+ /// @returns the evaluation stage for an expression of this variable type
+ EvaluationStage Stage() const { return stage_; }
+
/// @returns the storage class for the variable
ast::StorageClass StorageClass() const { return storage_class_; }
@@ -89,6 +94,7 @@
private:
const ast::Variable* const declaration_;
const sem::Type* const type_;
+ const EvaluationStage stage_;
const ast::StorageClass storage_class_;
const ast::Access access_;
const Constant* constant_value_;
@@ -102,12 +108,14 @@
/// Constructor
/// @param declaration the AST declaration node
/// @param type the variable type
+ /// @param stage the evaluation stage for an expression of this variable type
/// @param storage_class the variable storage class
/// @param access the variable access control type
/// @param statement the statement that declared this local variable
/// @param constant_value the constant value for the variable. May be null
LocalVariable(const ast::Variable* declaration,
const sem::Type* type,
+ EvaluationStage stage,
ast::StorageClass storage_class,
ast::Access access,
const sem::Statement* statement,
@@ -137,12 +145,14 @@
/// Constructor
/// @param declaration the AST declaration node
/// @param type the variable type
+ /// @param stage the evaluation stage for an expression of this variable type
/// @param storage_class the variable storage class
/// @param access the variable access control type
/// @param constant_value the constant value for the variable. May be null
/// @param binding_point the optional resource binding point of the variable
GlobalVariable(const ast::Variable* declaration,
const sem::Type* type,
+ EvaluationStage stage,
ast::StorageClass storage_class,
ast::Access access,
const Constant* constant_value,
diff --git a/src/tint/transform/vectorize_scalar_matrix_constructors_test.cc b/src/tint/transform/vectorize_scalar_matrix_constructors_test.cc
index f92df44..017af72 100644
--- a/src/tint/transform/vectorize_scalar_matrix_constructors_test.cc
+++ b/src/tint/transform/vectorize_scalar_matrix_constructors_test.cc
@@ -31,108 +31,6 @@
EXPECT_FALSE(ShouldRun<VectorizeScalarMatrixConstructors>(src));
}
-TEST_P(VectorizeScalarMatrixConstructorsTest, SingleScalars) {
- uint32_t cols = GetParam().first;
- uint32_t rows = GetParam().second;
- std::string matrix_no_type = "mat" + std::to_string(cols) + "x" + std::to_string(rows);
- std::string matrix = matrix_no_type + "<f32>";
- std::string vector = "vec" + std::to_string(rows) + "<f32>";
- std::string values;
- for (uint32_t c = 0; c < cols; c++) {
- if (c > 0) {
- values += ", ";
- }
- values += vector + "(";
- for (uint32_t r = 0; r < rows; r++) {
- if (r > 0) {
- values += ", ";
- }
- values += "value";
- }
- values += ")";
- }
-
- std::string src = R"(
-@fragment
-fn main() {
- let m = ${matrix}(42.0);
-}
-)";
-
- std::string expect = R"(
-fn build_${matrix_no_type}(value : f32) -> ${matrix} {
- return ${matrix}(${values});
-}
-
-@fragment
-fn main() {
- let m = build_${matrix_no_type}(42.0);
-}
-)";
- src = utils::ReplaceAll(src, "${matrix}", matrix);
- expect = utils::ReplaceAll(expect, "${matrix}", matrix);
- expect = utils::ReplaceAll(expect, "${matrix_no_type}", matrix_no_type);
- expect = utils::ReplaceAll(expect, "${values}", values);
-
- EXPECT_TRUE(ShouldRun<VectorizeScalarMatrixConstructors>(src));
-
- auto got = Run<VectorizeScalarMatrixConstructors>(src);
-
- EXPECT_EQ(expect, str(got));
-}
-
-TEST_P(VectorizeScalarMatrixConstructorsTest, SingleScalarsReference) {
- uint32_t cols = GetParam().first;
- uint32_t rows = GetParam().second;
- std::string matrix_no_type = "mat" + std::to_string(cols) + "x" + std::to_string(rows);
- std::string matrix = matrix_no_type + "<f32>";
- std::string vector = "vec" + std::to_string(rows) + "<f32>";
- std::string values;
- for (uint32_t c = 0; c < cols; c++) {
- if (c > 0) {
- values += ", ";
- }
- values += vector + "(";
- for (uint32_t r = 0; r < rows; r++) {
- if (r > 0) {
- values += ", ";
- }
- values += "value";
- }
- values += ")";
- }
-
- std::string src = R"(
-@fragment
-fn main() {
- let v = vec4<f32>(42.0);
- let m = ${matrix}(v[2]);
-}
-)";
-
- std::string expect = R"(
-fn build_${matrix_no_type}(value : f32) -> ${matrix} {
- return ${matrix}(${values});
-}
-
-@fragment
-fn main() {
- let v = vec4<f32>(42.0);
- let m = build_${matrix_no_type}(v[2]);
-}
-)";
- src = utils::ReplaceAll(src, "${matrix}", matrix);
- expect = utils::ReplaceAll(expect, "${matrix}", matrix);
- expect = utils::ReplaceAll(expect, "${matrix_no_type}", matrix_no_type);
- expect = utils::ReplaceAll(expect, "${values}", values);
-
- EXPECT_TRUE(ShouldRun<VectorizeScalarMatrixConstructors>(src));
-
- auto got = Run<VectorizeScalarMatrixConstructors>(src);
-
- EXPECT_EQ(expect, str(got));
-}
-
TEST_P(VectorizeScalarMatrixConstructorsTest, MultipleScalars) {
uint32_t cols = GetParam().first;
uint32_t rows = GetParam().second;
diff --git a/src/tint/utils/block_allocator.h b/src/tint/utils/block_allocator.h
index f413940..91a8a53 100644
--- a/src/tint/utils/block_allocator.h
+++ b/src/tint/utils/block_allocator.h
@@ -24,10 +24,10 @@
namespace tint::utils {
-/// A container and allocator of objects of (or deriving from) the template
-/// type `T`. Objects are allocated by calling Create(), and are owned by the
-/// BlockAllocator. When the BlockAllocator is destructed, all constructed
-/// objects are automatically destructed and freed.
+/// A container and allocator of objects of (or deriving from) the template type `T`.
+/// Objects are allocated by calling Create(), and are owned by the BlockAllocator.
+/// When the BlockAllocator is destructed, all constructed objects are automatically destructed and
+/// freed.
///
/// Objects held by the BlockAllocator can be iterated over using a View.
template <typename T, size_t BLOCK_SIZE = 64 * 1024, size_t BLOCK_ALIGNMENT = 16>
@@ -44,8 +44,7 @@
/// Block is linked list of memory blocks.
/// Blocks are allocated out of heap memory.
///
- /// Note: We're not using std::aligned_storage here as this warns / errors
- /// on MSVC.
+ /// Note: We're not using std::aligned_storage here as this warns / errors on MSVC.
struct alignas(BLOCK_ALIGNMENT) Block {
uint8_t data[BLOCK_SIZE];
Block* next;
@@ -97,22 +96,22 @@
size_t idx;
};
- /// View provides begin() and end() methods for looping over the objects
- /// owned by the BlockAllocator.
+ /// View provides begin() and end() methods for looping over the objects owned by the
+ /// BlockAllocator.
template <bool IS_CONST>
class TView {
public:
/// @returns an iterator to the beginning of the view
TIterator<IS_CONST> begin() const {
- return TIterator<IS_CONST>{allocator_->pointers_.root, 0};
+ return TIterator<IS_CONST>{allocator_->data.pointers.root, 0};
}
/// @returns an iterator to the end of the view
TIterator<IS_CONST> end() const {
- return allocator_->pointers_.current_index >= Pointers::kMax
+ return allocator_->data.pointers.current_index >= Pointers::kMax
? TIterator<IS_CONST>(nullptr, 0)
- : TIterator<IS_CONST>(allocator_->pointers_.current,
- allocator_->pointers_.current_index);
+ : TIterator<IS_CONST>(allocator_->data.pointers.current,
+ allocator_->data.pointers.current_index);
}
private:
@@ -128,12 +127,12 @@
/// An immutable iterator type over the objects of the BlockAllocator
using ConstIterator = TIterator<true>;
- /// View provides begin() and end() methods for looping over the objects
- /// owned by the BlockAllocator.
+ /// View provides begin() and end() methods for looping over the objects owned by the
+ /// BlockAllocator.
using View = TView<false>;
- /// ConstView provides begin() and end() methods for looping over the objects
- /// owned by the BlockAllocator.
+ /// ConstView provides begin() and end() methods for looping over the objects owned by the
+ /// BlockAllocator.
using ConstView = TView<true>;
/// Constructor
@@ -141,10 +140,7 @@
/// Move constructor
/// @param rhs the BlockAllocator to move
- BlockAllocator(BlockAllocator&& rhs) {
- std::swap(block_, rhs.block_);
- std::swap(pointers_, rhs.pointers_);
- }
+ BlockAllocator(BlockAllocator&& rhs) { std::swap(data, rhs.data); }
/// Move assignment operator
/// @param rhs the BlockAllocator to move
@@ -152,8 +148,7 @@
BlockAllocator& operator=(BlockAllocator&& rhs) {
if (this != &rhs) {
Reset();
- std::swap(block_, rhs.block_);
- std::swap(pointers_, rhs.pointers_);
+ std::swap(data, rhs.data);
}
return *this;
}
@@ -168,8 +163,7 @@
ConstView Objects() const { return ConstView(this); }
/// Creates a new `TYPE` owned by the BlockAllocator.
- /// When the BlockAllocator is destructed the object will be destructed and
- /// freed.
+ /// When the BlockAllocator is destructed the object will be destructed and freed.
/// @param args the arguments to pass to the type constructor
/// @returns the pointer to the constructed object
template <typename TYPE = T, typename... ARGS>
@@ -183,6 +177,7 @@
auto* ptr = Allocate<TYPE>();
new (ptr) TYPE(std::forward<ARGS>(args)...);
AddObjectPointer(ptr);
+ data.count++;
return ptr;
}
@@ -192,97 +187,106 @@
for (auto ptr : Objects()) {
ptr->~T();
}
- auto* block = block_.root;
+ auto* block = data.block.root;
while (block != nullptr) {
auto* next = block->next;
delete block;
block = next;
}
- block_ = {};
- pointers_ = {};
+ data = {};
}
+ /// @returns the total number of allocated objects.
+ size_t Count() const { return data.count; }
+
private:
BlockAllocator(const BlockAllocator&) = delete;
BlockAllocator& operator=(const BlockAllocator&) = delete;
- /// Allocates an instance of TYPE from the current block, or from a newly
- /// allocated block if the current block is full.
+ /// Allocates an instance of TYPE from the current block, or from a newly allocated block if the
+ /// current block is full.
template <typename TYPE>
TYPE* Allocate() {
static_assert(sizeof(TYPE) <= BLOCK_SIZE,
"Cannot construct TYPE with size greater than BLOCK_SIZE");
static_assert(alignof(TYPE) <= BLOCK_ALIGNMENT, "alignof(TYPE) is greater than ALIGNMENT");
- block_.current_offset = utils::RoundUp(alignof(TYPE), block_.current_offset);
- if (block_.current_offset + sizeof(TYPE) > BLOCK_SIZE) {
+ auto& block = data.block;
+
+ block.current_offset = utils::RoundUp(alignof(TYPE), block.current_offset);
+ if (block.current_offset + sizeof(TYPE) > BLOCK_SIZE) {
// Allocate a new block from the heap
- auto* prev_block = block_.current;
- block_.current = new Block;
- if (!block_.current) {
+ auto* prev_block = block.current;
+ block.current = new Block;
+ if (!block.current) {
return nullptr; // out of memory
}
- block_.current->next = nullptr;
- block_.current_offset = 0;
+ block.current->next = nullptr;
+ block.current_offset = 0;
if (prev_block) {
- prev_block->next = block_.current;
+ prev_block->next = block.current;
} else {
- block_.root = block_.current;
+ block.root = block.current;
}
}
- auto* base = &block_.current->data[0];
- auto* ptr = utils::Bitcast<TYPE*>(base + block_.current_offset);
- block_.current_offset += sizeof(TYPE);
+ auto* base = &block.current->data[0];
+ auto* ptr = utils::Bitcast<TYPE*>(base + block.current_offset);
+ block.current_offset += sizeof(TYPE);
return ptr;
}
/// Adds `ptr` to the linked list of objects owned by this BlockAllocator.
- /// Once added, `ptr` will be tracked for destruction when the BlockAllocator
- /// is destructed.
+ /// Once added, `ptr` will be tracked for destruction when the BlockAllocator is destructed.
void AddObjectPointer(T* ptr) {
- if (pointers_.current_index >= Pointers::kMax) {
- auto* prev_pointers = pointers_.current;
- pointers_.current = Allocate<Pointers>();
- if (!pointers_.current) {
+ auto& pointers = data.pointers;
+
+ if (pointers.current_index >= Pointers::kMax) {
+ auto* prev_pointers = pointers.current;
+ pointers.current = Allocate<Pointers>();
+ if (!pointers.current) {
return; // out of memory
}
- pointers_.current->next = nullptr;
- pointers_.current_index = 0;
+ pointers.current->next = nullptr;
+ pointers.current_index = 0;
if (prev_pointers) {
- prev_pointers->next = pointers_.current;
+ prev_pointers->next = pointers.current;
} else {
- pointers_.root = pointers_.current;
+ pointers.root = pointers.current;
}
}
- pointers_.current->ptrs[pointers_.current_index++] = ptr;
+ pointers.current->ptrs[pointers.current_index++] = ptr;
}
struct {
- /// The root block of the block linked list
- Block* root = nullptr;
- /// The current (end) block of the blocked linked list.
- /// New allocations come from this block
- Block* current = nullptr;
- /// The byte offset in #current for the next allocation.
- /// Initialized with BLOCK_SIZE so that the first allocation triggers a
- /// block allocation.
- size_t current_offset = BLOCK_SIZE;
- } block_;
+ struct {
+ /// The root block of the block linked list
+ Block* root = nullptr;
+ /// The current (end) block of the blocked linked list.
+ /// New allocations come from this block
+ Block* current = nullptr;
+ /// The byte offset in #current for the next allocation.
+ /// Initialized with BLOCK_SIZE so that the first allocation triggers a block
+ /// allocation.
+ size_t current_offset = BLOCK_SIZE;
+ } block;
- struct {
- /// The root Pointers structure of the pointers linked list
- Pointers* root = nullptr;
- /// The current (end) Pointers structure of the pointers linked list.
- /// AddObjectPointer() adds to this structure.
- Pointers* current = nullptr;
- /// The array index in #current for the next append.
- /// Initialized with Pointers::kMax so that the first append triggers a
- /// allocation of the Pointers structure.
- size_t current_index = Pointers::kMax;
- } pointers_;
+ struct {
+ /// The root Pointers structure of the pointers linked list
+ Pointers* root = nullptr;
+ /// The current (end) Pointers structure of the pointers linked list.
+ /// AddObjectPointer() adds to this structure.
+ Pointers* current = nullptr;
+ /// The array index in #current for the next append.
+ /// Initialized with Pointers::kMax so that the first append triggers a allocation of
+ /// the Pointers structure.
+ size_t current_index = Pointers::kMax;
+ } pointers;
+
+ size_t count = 0;
+ } data;
};
} // namespace tint::utils
diff --git a/src/tint/utils/block_allocator_test.cc b/src/tint/utils/block_allocator_test.cc
index 77ea3e3..1684755 100644
--- a/src/tint/utils/block_allocator_test.cc
+++ b/src/tint/utils/block_allocator_test.cc
@@ -33,6 +33,7 @@
Allocator allocator;
+ EXPECT_EQ(allocator.Count(), 0u);
for (int* i : allocator.Objects()) {
(void)i;
if ((true)) { // Workaround for "error: loop will run at most once"
@@ -47,6 +48,19 @@
}
}
+TEST_F(BlockAllocatorTest, Count) {
+ using Allocator = BlockAllocator<int>;
+
+ for (size_t n : {0u, 1u, 10u, 16u, 20u, 32u, 50u, 64u, 100u, 256u, 300u, 512u, 500u, 512u}) {
+ Allocator allocator;
+ EXPECT_EQ(allocator.Count(), 0u);
+ for (size_t i = 0; i < n; i++) {
+ allocator.Create(123);
+ }
+ EXPECT_EQ(allocator.Count(), n);
+ }
+}
+
TEST_F(BlockAllocatorTest, ObjectLifetime) {
using Allocator = BlockAllocator<LifetimeCounter>;
@@ -75,9 +89,11 @@
allocator_a.Create(&count);
}
EXPECT_EQ(count, n);
+ EXPECT_EQ(allocator_a.Count(), n);
Allocator allocator_b{std::move(allocator_a)};
EXPECT_EQ(count, n);
+ EXPECT_EQ(allocator_b.Count(), n);
}
EXPECT_EQ(count, 0u);
@@ -97,16 +113,19 @@
allocator_a.Create(&count_a);
}
EXPECT_EQ(count_a, n);
+ EXPECT_EQ(allocator_a.Count(), n);
Allocator allocator_b;
for (size_t i = 0; i < n; i++) {
allocator_b.Create(&count_b);
}
EXPECT_EQ(count_b, n);
+ EXPECT_EQ(allocator_b.Count(), n);
allocator_b = std::move(allocator_a);
EXPECT_EQ(count_a, n);
EXPECT_EQ(count_b, 0u);
+ EXPECT_EQ(allocator_b.Count(), n);
}
EXPECT_EQ(count_a, 0u);
diff --git a/src/tint/writer/append_vector.cc b/src/tint/writer/append_vector.cc
index c5f184d..28845d9 100644
--- a/src/tint/writer/append_vector.cc
+++ b/src/tint/writer/append_vector.cc
@@ -59,7 +59,8 @@
<< "unsupported vector element type: " << ty->TypeInfo().name;
return nullptr;
}
- auto* sem = b.create<sem::Expression>(expr, ty, stmt, /* constant_value */ nullptr,
+ auto* sem = b.create<sem::Expression>(expr, ty, sem::EvaluationStage::kRuntime, stmt,
+ /* constant_value */ nullptr,
/* has_side_effects */ false);
b.Sem().Add(expr, sem);
return sem;
@@ -136,10 +137,12 @@
auto* scalar_cast_target = b->create<sem::TypeConversion>(
packed_el_sem_ty,
b->create<sem::Parameter>(nullptr, 0u, scalar_sem->Type()->UnwrapRef(),
- ast::StorageClass::kNone, ast::Access::kUndefined));
+ ast::StorageClass::kNone, ast::Access::kUndefined),
+ sem::EvaluationStage::kRuntime);
auto* scalar_cast_sem = b->create<sem::Call>(
- scalar_cast_ast, scalar_cast_target, std::vector<const sem::Expression*>{scalar_sem},
- statement, /* constant_value */ nullptr, /* has_side_effects */ false);
+ scalar_cast_ast, scalar_cast_target, sem::EvaluationStage::kRuntime,
+ std::vector<const sem::Expression*>{scalar_sem}, statement,
+ /* constant_value */ nullptr, /* has_side_effects */ false);
b->Sem().Add(scalar_cast_ast, scalar_cast_sem);
packed.emplace_back(scalar_cast_sem);
} else {
@@ -151,15 +154,17 @@
utils::Transform(packed, [&](const sem::Expression* expr) { return expr->Declaration(); }));
auto* constructor_target = b->create<sem::TypeConstructor>(
packed_sem_ty,
- utils::Transform(
- packed, [&](const tint::sem::Expression* arg, size_t i) -> const sem::Parameter* {
- return b->create<sem::Parameter>(nullptr, static_cast<uint32_t>(i),
- arg->Type()->UnwrapRef(), ast::StorageClass::kNone,
- ast::Access::kUndefined);
- }));
- auto* constructor_sem = b->create<sem::Call>(constructor_ast, constructor_target, packed,
- statement, /* constant_value */ nullptr,
- /* has_side_effects */ false);
+ utils::Transform(packed,
+ [&](const tint::sem::Expression* arg, size_t i) -> const sem::Parameter* {
+ return b->create<sem::Parameter>(
+ nullptr, static_cast<uint32_t>(i), arg->Type()->UnwrapRef(),
+ ast::StorageClass::kNone, ast::Access::kUndefined);
+ }),
+ sem::EvaluationStage::kRuntime);
+ auto* constructor_sem =
+ b->create<sem::Call>(constructor_ast, constructor_target, sem::EvaluationStage::kRuntime,
+ packed, statement, /* constant_value */ nullptr,
+ /* has_side_effects */ false);
b->Sem().Add(constructor_ast, constructor_sem);
return constructor_sem;
}
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index 767fecb..88eec26 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -500,42 +500,45 @@
bool GeneratorImpl::EmitFloatModulo(std::ostream& out, const ast::BinaryExpression* expr) {
std::string fn;
auto* ret_ty = TypeOf(expr)->UnwrapRef();
- fn = utils::GetOrCreate(float_modulo_funcs_, ret_ty, [&]() -> std::string {
- TextBuffer b;
- TINT_DEFER(helpers_.Append(b));
+ auto* lhs_ty = TypeOf(expr->lhs)->UnwrapRef();
+ auto* rhs_ty = TypeOf(expr->rhs)->UnwrapRef();
+ fn = utils::GetOrCreate(float_modulo_funcs_, BinaryOperandType{{lhs_ty, rhs_ty}},
+ [&]() -> std::string {
+ TextBuffer b;
+ TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier("tint_float_modulo");
- std::vector<std::string> parameter_names;
- {
- auto decl = line(&b);
- if (!EmitTypeAndName(decl, ret_ty, ast::StorageClass::kNone, ast::Access::kUndefined,
- fn_name)) {
- return "";
- }
- {
- ScopedParen sp(decl);
- const auto* ty = TypeOf(expr->lhs)->UnwrapRef();
- if (!EmitTypeAndName(decl, ty, ast::StorageClass::kNone, ast::Access::kUndefined,
- "lhs")) {
- return "";
- }
- decl << ", ";
- ty = TypeOf(expr->rhs)->UnwrapRef();
- if (!EmitTypeAndName(decl, ty, ast::StorageClass::kNone, ast::Access::kUndefined,
- "rhs")) {
- return "";
- }
- }
- decl << " {";
- }
- {
- ScopedIndent si(&b);
- line(&b) << "return (lhs - rhs * trunc(lhs / rhs));";
- }
- line(&b) << "}";
- line(&b);
- return fn_name;
- });
+ auto fn_name = UniqueIdentifier("tint_float_modulo");
+ std::vector<std::string> parameter_names;
+ {
+ auto decl = line(&b);
+ if (!EmitTypeAndName(decl, ret_ty, ast::StorageClass::kNone,
+ ast::Access::kUndefined, fn_name)) {
+ return "";
+ }
+ {
+ ScopedParen sp(decl);
+ const auto* ty = TypeOf(expr->lhs)->UnwrapRef();
+ if (!EmitTypeAndName(decl, ty, ast::StorageClass::kNone,
+ ast::Access::kUndefined, "lhs")) {
+ return "";
+ }
+ decl << ", ";
+ ty = TypeOf(expr->rhs)->UnwrapRef();
+ if (!EmitTypeAndName(decl, ty, ast::StorageClass::kNone,
+ ast::Access::kUndefined, "rhs")) {
+ return "";
+ }
+ }
+ decl << " {";
+ }
+ {
+ ScopedIndent si(&b);
+ line(&b) << "return (lhs - rhs * trunc(lhs / rhs));";
+ }
+ line(&b) << "}";
+ line(&b);
+ return fn_name;
+ });
if (fn.empty()) {
return false;
@@ -1336,7 +1339,8 @@
const ast::Expression* GeneratorImpl::CreateF32Zero(const sem::Statement* stmt) {
auto* zero = builder_.Expr(0_f);
auto* f32 = builder_.create<sem::F32>();
- auto* sem_zero = builder_.create<sem::Expression>(zero, f32, stmt, /* constant_value */ nullptr,
+ auto* sem_zero = builder_.create<sem::Expression>(zero, f32, sem::EvaluationStage::kRuntime,
+ stmt, /* constant_value */ nullptr,
/* has_side_effects */ false);
builder_.Sem().Add(zero, sem_zero);
return zero;
diff --git a/src/tint/writer/glsl/generator_impl.h b/src/tint/writer/glsl/generator_impl.h
index 58a0e50..811dd91 100644
--- a/src/tint/writer/glsl/generator_impl.h
+++ b/src/tint/writer/glsl/generator_impl.h
@@ -16,6 +16,7 @@
#define SRC_TINT_WRITER_GLSL_GENERATOR_IMPL_H_
#include <string>
+#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
@@ -478,19 +479,9 @@
std::string var_name;
};
- struct DMAIntrinsic {
- transform::DecomposeMemoryAccess::Intrinsic::Op op;
- transform::DecomposeMemoryAccess::Intrinsic::DataType type;
- bool operator==(const DMAIntrinsic& rhs) const { return op == rhs.op && type == rhs.type; }
- /// Hasher is a std::hash function for DMAIntrinsic
- struct Hasher {
- /// @param i the DMAIntrinsic to hash
- /// @returns the hash of `i`
- inline std::size_t operator()(const DMAIntrinsic& i) const {
- return utils::Hash(i.op, i.type);
- }
- };
- };
+ /// The map key for two semantic types.
+ using BinaryOperandType =
+ utils::UnorderedKeyWrapper<std::tuple<const sem::Type*, const sem::Type*>>;
/// CallBuiltinHelper will call the builtin helper function, creating it
/// if it hasn't been built already. If the builtin needs to be built then
@@ -518,11 +509,10 @@
TextBuffer helpers_; // Helper functions emitted at the top of the output
std::function<bool()> emit_continuing_;
- std::unordered_map<DMAIntrinsic, std::string, DMAIntrinsic::Hasher> dma_intrinsics_;
std::unordered_map<const sem::Builtin*, std::string> builtins_;
std::unordered_map<const sem::Vector*, std::string> dynamic_vector_write_;
std::unordered_map<const sem::Vector*, std::string> int_dot_funcs_;
- std::unordered_map<const sem::Type*, std::string> float_modulo_funcs_;
+ std::unordered_map<BinaryOperandType, std::string> float_modulo_funcs_;
std::unordered_set<const sem::Struct*> emitted_structs_;
bool requires_oes_sample_variables_ = false;
bool requires_default_precision_qualifier_ = false;
diff --git a/src/tint/writer/glsl/generator_impl_binary_test.cc b/src/tint/writer/glsl/generator_impl_binary_test.cc
index b529255..a9ccffd 100644
--- a/src/tint/writer/glsl/generator_impl_binary_test.cc
+++ b/src/tint/writer/glsl/generator_impl_binary_test.cc
@@ -273,6 +273,76 @@
EXPECT_EQ(out.str(), "tint_float_modulo(a, b)");
}
+TEST_F(GlslGeneratorImplTest_Binary, ModVec3F32ScalarF32) {
+ GlobalVar("a", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+ GlobalVar("b", ty.f32(), ast::StorageClass::kPrivate);
+
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
+ WrapInFunction(expr);
+
+ GeneratorImpl& gen = Build();
+
+ std::stringstream out;
+ ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+ EXPECT_EQ(out.str(), "tint_float_modulo(a, b)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, ModScalarF32Vec3F32) {
+ GlobalVar("a", ty.f32(), ast::StorageClass::kPrivate);
+ GlobalVar("b", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+
+ auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
+ WrapInFunction(expr);
+
+ GeneratorImpl& gen = Build();
+
+ std::stringstream out;
+ ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
+ EXPECT_EQ(out.str(), "tint_float_modulo(a, b)");
+}
+
+TEST_F(GlslGeneratorImplTest_Binary, ModMixedVec3ScalarF32) {
+ GlobalVar("a", ty.vec3<f32>(), ast::StorageClass::kPrivate);
+ GlobalVar("b", ty.f32(), ast::StorageClass::kPrivate);
+
+ auto* expr_vec_mod_vec =
+ create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("a"));
+ auto* expr_vec_mod_scalar =
+ create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("a"), Expr("b"));
+ auto* expr_scalar_mod_vec =
+ create<ast::BinaryExpression>(ast::BinaryOp::kModulo, Expr("b"), Expr("a"));
+ WrapInFunction(expr_vec_mod_vec, expr_vec_mod_scalar, expr_scalar_mod_vec);
+
+ GeneratorImpl& gen = Build();
+
+ ASSERT_TRUE(gen.Generate()) << gen.error();
+ EXPECT_EQ(gen.result(), R"(#version 310 es
+
+vec3 tint_float_modulo(vec3 lhs, vec3 rhs) {
+ return (lhs - rhs * trunc(lhs / rhs));
+}
+
+vec3 tint_float_modulo_1(vec3 lhs, float rhs) {
+ return (lhs - rhs * trunc(lhs / rhs));
+}
+
+vec3 tint_float_modulo_2(float lhs, vec3 rhs) {
+ return (lhs - rhs * trunc(lhs / rhs));
+}
+
+
+vec3 a = vec3(0.0f, 0.0f, 0.0f);
+float b = 0.0f;
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+void test_function() {
+ vec3 tint_symbol = tint_float_modulo(a, a);
+ vec3 tint_symbol_1 = tint_float_modulo_1(a, b);
+ vec3 tint_symbol_2 = tint_float_modulo_2(b, a);
+ return;
+}
+)");
+}
+
TEST_F(GlslGeneratorImplTest_Binary, Logical_Multi) {
// (a && b) || (c || d)
GlobalVar("a", ty.bool_(), ast::StorageClass::kPrivate);
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 0a6a196..e8ab2c7 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -2392,7 +2392,8 @@
auto* zero = builder_.Expr(0_i);
auto* stmt = builder_.Sem().Get(vector)->Stmt();
builder_.Sem().Add(
- zero, builder_.create<sem::Expression>(zero, i32, stmt, /* constant_value */ nullptr,
+ zero, builder_.create<sem::Expression>(zero, i32, sem::EvaluationStage::kRuntime, stmt,
+ /* constant_value */ nullptr,
/* has_side_effects */ false));
auto* packed = AppendVector(&builder_, vector, zero);
return EmitExpression(out, packed->Declaration());
