| // Copyright 2021 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // WGSL builtin definition file // |
| // // |
| // This file is used to generate parts of the Tint BuiltinTable, various // |
| // enum definition files, as well as test .wgsl files. // |
| // // |
| // After modifying this file, run: // |
| // tools/run gen // |
| // from the Dawn source directory. // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| import "src/tint/lang/core/access.def" |
| import "src/tint/lang/core/address_space.def" |
| import "src/tint/lang/core/texel_format.def" |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Enumerators // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#filterable-triggering-rules |
| enum core_diagnostic_rule { |
| // Rules defined in the spec. |
| derivative_uniformity |
| } |
| |
| // chromium-specific diagnostics |
| enum chromium_diagnostic_rule { |
| // Chromium specific rules not defined in the spec. |
| unreachable_code |
| } |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#syntax-severity_control_name |
| enum diagnostic_severity { |
| error |
| warning |
| info |
| off |
| } |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#extension |
| enum extension { |
| // WGSL Extension "f16" |
| f16 |
| // A Chromium-specific extension for disabling uniformity analysis. |
| chromium_disable_uniformity_analysis |
| // A Chromium-specific extension for push constants |
| chromium_experimental_push_constant |
| // A Chromium-specific extension that adds basic subgroup functionality. |
| chromium_experimental_subgroups |
| // A Chromium-specific extension that relaxes memory layout requirements for uniform storage. |
| chromium_internal_relaxed_uniform_layout |
| // A Chromium-specific extension that enables dual source blending. |
| chromium_internal_dual_source_blending |
| // A Chromium-specific extension that enables pixel local storage. |
| // Cannot be used with chromium_experimental_framebuffer_fetch |
| chromium_experimental_pixel_local |
| // A Chromium-specific extension that enables framebuffer fetching. |
| // Cannot be used with chromium_experimental_pixel_local |
| chromium_experimental_framebuffer_fetch |
| } |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#language-extensions-sec |
| enum language_feature { |
| packed_4x8_integer_dot_product |
| pointer_composite_access |
| readonly_and_readwrite_storage_textures |
| unrestricted_pointer_parameters |
| |
| // Language features used only for testing whose status will never change. |
| chromium_testing_unimplemented |
| chromium_testing_unsafe_experimental |
| chromium_testing_experimental |
| chromium_testing_shipped_with_killswitch |
| chromium_testing_shipped |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // WGSL primitive types // |
| // Types may be decorated with @precedence(N) to prioritize which type // |
| // will be picked when multiple types of a matcher match. // |
| // This is used to ensure that abstract numerical types materialize to the // |
| // concrete type with the lowest conversion rank. // |
| // Types with higher the precedence values will be matched first. // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#plain-types-section |
| type bool |
| @precedence(5) @display("abstract-int") type ia |
| @precedence(4) @display("abstract-float") type fa |
| @precedence(3) type i32 |
| @precedence(2) type u32 |
| @precedence(1) type f32 |
| @precedence(0) type f16 |
| type vec2<T> |
| type vec3<T> |
| type vec4<T> |
| type mat2x2<T> |
| type mat2x3<T> |
| type mat2x4<T> |
| type mat3x2<T> |
| type mat3x3<T> |
| type mat3x4<T> |
| type mat4x2<T> |
| type mat4x3<T> |
| type mat4x4<T> |
| @display("vec{N}<{T}>") type vec<N: num, T> |
| @display("mat{N}x{M}<{T}>") type mat<N: num, M: num, T> |
| type ptr<S: address_space, T, A: access> |
| type atomic<T> |
| type array<T> |
| type sampler |
| type sampler_comparison |
| type texture_1d<T> |
| type texture_2d<T> |
| type texture_2d_array<T> |
| type texture_3d<T> |
| type texture_cube<T> |
| type texture_cube_array<T> |
| type texture_multisampled_2d<T> |
| type texture_depth_2d |
| type texture_depth_2d_array |
| type texture_depth_cube |
| type texture_depth_cube_array |
| type texture_depth_multisampled_2d |
| type texture_storage_1d<F: texel_format, A: access> |
| type texture_storage_2d<F: texel_format, A: access> |
| type texture_storage_2d_array<F: texel_format, A: access> |
| type texture_storage_3d<F: texel_format, A: access> |
| type texture_external |
| type packedVec3<T> |
| |
| @display("__modf_result_{T}") type __modf_result<T> |
| @display("__modf_result_vec{N}_{T}") type __modf_result_vec<N: num, T> |
| @display("__frexp_result_{T}") type __frexp_result<T> |
| @display("__frexp_result_vec{N}_{T}") type __frexp_result_vec<N: num, T> |
| |
| type __atomic_compare_exchange_result<T> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Type matchers // |
| // // |
| // A type matcher that can match one or more types. // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| match scalar: ia | fa | f32 | f16 | i32 | u32 | bool |
| match concrete_scalar: f32 | f16 | i32 | u32 | bool |
| match scalar_no_f32: ia | fa | i32 | f16 | u32 | bool |
| match scalar_no_f16: ia | fa | f32 | i32 | u32 | bool |
| match scalar_no_i32: ia | fa | f32 | f16 | u32 | bool |
| match scalar_no_u32: ia | fa | f32 | f16 | i32 | bool |
| match scalar_no_bool: ia | fa | f32 | f16 | i32 | u32 |
| match fia_fiu32_f16: fa | ia | f32 | i32 | u32 | f16 |
| match fia_fi32_f16: fa | ia | f32 | i32 | f16 |
| match fia_fiu32: fa | ia | f32 | i32 | u32 |
| match fa_f32: fa | f32 |
| match fa_f32_f16: fa | f32 | f16 |
| match ia_iu32: ia | i32 | u32 |
| match ia_i32: ia | i32 |
| match fiu32_f16: f32 | i32 | u32 | f16 |
| match fiu32: f32 | i32 | u32 |
| match fi32_f16: f32 | i32 | f16 |
| match fi32: f32 | i32 |
| match f32_f16: f32 | f16 |
| match iu32: i32 | u32 |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Enum matchers // |
| // // |
| // A number matcher that can match one or more enumerator values. // |
| // All enumerator values listed in the match declaration need to be from the // |
| // same enum. // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#texel-formats |
| match f32_texel_format |
| : texel_format.bgra8unorm |
| | texel_format.rgba8unorm |
| | texel_format.rgba8snorm |
| | texel_format.rgba16float |
| | texel_format.r32float |
| | texel_format.rg32float |
| | texel_format.rgba32float |
| match i32_texel_format |
| : texel_format.rgba8sint |
| | texel_format.rgba16sint |
| | texel_format.r32sint |
| | texel_format.rg32sint |
| | texel_format.rgba32sint |
| match u32_texel_format |
| : texel_format.rgba8uint |
| | texel_format.rgba16uint |
| | texel_format.r32uint |
| | texel_format.rg32uint |
| | texel_format.rgba32uint |
| |
| match write: access.write |
| match read_write: access.read_write |
| match readable |
| : access.read |
| | access.read_write |
| match writable |
| : access.write |
| | access.read_write |
| |
| match function_private_workgroup |
| : address_space.function |
| | address_space.private |
| | address_space.workgroup |
| match workgroup_or_storage |
| : address_space.workgroup |
| | address_space.storage |
| match storage |
| : address_space.storage |
| match workgroup |
| : address_space.workgroup |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Builtin Functions // |
| // // |
| // The builtin function declarations below declare all the built-in // |
| // functions supported by the WGSL language. This builtin definition // |
| // language supports simple static-type function declarations, as well as // |
| // single overload declarations that can match a number of different // |
| // argument types via the use of template types and template numbers // |
| // // |
| // * Basic example: // |
| // // |
| // fn isInf(f32) -> bool // |
| // // |
| // Declares an overload of the function 'isInf' that accepts a single // |
| // parameter of type 'f32' and returns a 'bool'. // |
| // // |
| // A template type is a type determined by the arguments to the builtin. // |
| // // |
| // * Template type example without constraint: // |
| // // |
| // fn arrayLength<T>(array<T>) -> u32 // |
| // // |
| // Declares an overload of the function 'arrayLength' that accepts a // |
| // single argument of an array type with no constraints on the array // |
| // element type. This overload will always return a value of the same type // |
| // as its single argument. // |
| // // |
| // * Template type example with constraint: // |
| // // |
| // fn abs<T: fiu32>(T) -> T // |
| // // |
| // Declares an overload of the function 'abs' that accepts a single // |
| // argument of type 'f32', 'i32' or 'u32', which returns a value of the // |
| // same argument type. // |
| // // |
| // Similarly a template number is a number or enumerator that is determined // |
| // by the arguments to the builtin. // |
| // // |
| // * Template number example: // |
| // // |
| // fn dpdx<N: num>(vec<N, f32>) -> vec<N, f32> // |
| // // |
| // Declares an overload of the function 'dpdx' that accepts a single // |
| // argument of a variable-sized vector of 'f32', which returns a value of // |
| // the same argument type. // |
| // // |
| // // |
| // Matching algorithm for a single overload: // |
| // ----------------------------------------- // |
| // // |
| // The goal of matching is to compare a function call's arguments and any // |
| // explicitly provided template types in the program source against an // |
| // overload declaration in this file, and determine if the call satisfies // |
| // the form and type constraints of the overload. If the call matches an // |
| // overload, then the overload is added to the list of 'overload candidates' // |
| // used for overload resolution (described below). // |
| // // |
| // Prior to matching an overload, all template types are undefined. // |
| // // |
| // Template types are first defined with the type of the leftmost argument // |
| // that matches against that template type name. Subsequent arguments that // |
| // attempt to match against the template type name will either reject the // |
| // overload or refine the template, in one of 3 ways: // |
| // (a) Fail to match, causing the overload to be immediately rejected. // |
| // (b) Match the existing template type, either exactly or via implicit // |
| // conversion, and overload resolution continues. // |
| // (c) Match via implicit conversion of the currently defined template type // |
| // to the argument type. In this situation, the template type is refined // |
| // with the more constrained argument type, and overload resolution // |
| // continues. // |
| // // |
| // To better understand, let's consider the following hypothetical overload // |
| // declaration: // |
| // // |
| // fn foo<T: scalar>(T, T); // |
| // // |
| // T - is the template type name // |
| // scalar - is a matcher for the types 'f32', 'i32', 'u32' or 'bool' // |
| // (declared above) // |
| // <T: scalar> - declares the template type T, with the constraint that T // |
| // must match one of 'f32', 'i32', 'u32' or 'bool'. // |
| // // |
| // The process for resolving this overload is as follows: // |
| // // |
| // (1) The overload resolver begins by attempting to match the argument // |
| // types from left to right. // |
| // The first parameter type is compared against the argument type T. // |
| // As the template type T has not been defined yet, T is defined as the // |
| // type of the first argument. // |
| // There's no verification that the T type is a scalar at this stage. // |
| // (2) The second parameter is then compared against the second argument. // |
| // As the template type T is now defined the argument type is compared // |
| // against the value of the defined type of T. Depending on the // |
| // comparison of the argument type to the template type, either the // |
| // actions of (a), (b) or (c) from above will occur. // |
| // (3) If all the parameters matched, constraints on the template types // |
| // need to be checked next. If the defined type does not match the // |
| // 'match' constraint, then the overload is no longer considered. // |
| // // |
| // This algorithm for matching a single overload is less general than the // |
| // algorithm described in the WGSL spec. But it makes the same decisions // |
| // because the overloads defined by WGSL are monotonic in the sense that once // |
| // a template parameter has been refined, there is never a need to backtrack // |
| // and un-refine it to match a later argument. // |
| // // |
| // The algorithm for matching template numbers is similar to matching // |
| // template types, except numbers need to exactly match across all uses - // |
| // there is no implicit conversion. Template numbers may match integer // |
| // numbers or enumerators. // |
| // // |
| // // |
| // Overload resolution for candidate overloads // |
| // ------------------------------------------- // |
| // // |
| // If multiple candidate overloads match a given set of arguments, then a // |
| // final overload resolution pass needs to be performed. The arguments and // |
| // overload parameter types for each candidate overload are compared, // |
| // following the algorithm described at: // |
| // https://www.w3.org/TR/WGSL/#overload-resolution-section // |
| // // |
| // If the candidate list contains a single entry, then that single candidate // |
| // is picked, and no overload resolution needs to be performed. // |
| // // |
| // If the candidate list is empty, then the call fails to resolve and an // |
| // error diagnostic is raised. // |
| // // |
| // // |
| // More examples // |
| // ------------- // |
| // // |
| // fn F() // |
| // - Function called F. // |
| // No template types or numbers, no parameters, no return value // |
| // // |
| // fn F() -> RETURN_TYPE // |
| // - Function with RETURN_TYPE as the return type value // |
| // // |
| // fn F(f32, i32) // |
| // - Two fixed-type, anonymous parameters // |
| // // |
| // fn F(USAGE : f32) // |
| // - Single parameter with name USAGE. // |
| // Note: Parameter names are used by Tint to infer parameter order for // |
| // some builtin functions // |
| // // |
| // fn F<T>(T) // |
| // - Single parameter of unconstrained template type T (any type) // |
| // // |
| // fn F<T: scalar>(T) // |
| // - Single parameter of constrained template type T (must be a scalar) // |
| // // |
| // fn F<T: fiu32>(T) -> T // |
| // - Single parameter of constrained template type T (must be a one of // |
| // fiu32) Return type matches parameter type // |
| // // |
| // fn F<T, N: num>(vec<N, T>) // |
| // - Single parameter of vector type with template number size N and // |
| // element template type T // |
| // // |
| // fn F<A: access>(texture_storage_1d<f32_texel_format, A>) // |
| // - Single parameter of texture_storage_1d type with template number // |
| // access-control C, and of a texel format that is listed in // |
| // f32_texel_format // |
| // // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // https://gpuweb.github.io/gpuweb/wgsl/#builtin-functions |
| @must_use @const fn abs<T: fia_fiu32_f16>(T) -> T |
| @must_use @const fn abs<N: num, T: fia_fiu32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn acos<T: fa_f32_f16>(@test_value(0.96891242171) T) -> T |
| @must_use @const fn acos<N: num, T: fa_f32_f16>(@test_value(0.96891242171) vec<N, T>) -> vec<N, T> |
| @must_use @const fn acosh<T: fa_f32_f16>(@test_value(1.5430806348) T) -> T |
| @must_use @const fn acosh<N: num, T: fa_f32_f16>(@test_value(1.5430806348) vec<N, T>) -> vec<N, T> |
| @must_use @const fn all(bool) -> bool |
| @must_use @const fn all<N: num>(vec<N, bool>) -> bool |
| @must_use @const fn any(bool) -> bool |
| @must_use @const fn any<N: num>(vec<N, bool>) -> bool |
| @must_use fn arrayLength<T, A: access>(ptr<storage, array<T>, A>) -> u32 |
| @must_use @const fn asin<T: fa_f32_f16>(@test_value(0.479425538604) T) -> T |
| @must_use @const fn asin<N: num, T: fa_f32_f16>(@test_value(0.479425538604) vec<N, T>) -> vec<N, T> |
| @must_use @const fn asinh<T: fa_f32_f16>(T) -> T |
| @must_use @const fn asinh<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn atan<T: fa_f32_f16>(T) -> T |
| @must_use @const fn atan<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn atan2<T: fa_f32_f16>(T, T) -> T |
| @must_use @const fn atan2<T: fa_f32_f16, N: num>(vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn atanh<T: fa_f32_f16>(@test_value(0.5) T) -> T |
| @must_use @const fn atanh<N: num, T: fa_f32_f16>(@test_value(0.5) vec<N, T>) -> vec<N, T> |
| @must_use @const fn ceil<T: fa_f32_f16>(@test_value(1.5) T) -> T |
| @must_use @const fn ceil<N: num, T: fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> |
| @must_use @const fn clamp<T: fia_fiu32_f16>(T, T, T) -> T |
| @must_use @const fn clamp<T: fia_fiu32_f16, N: num>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn cos<T: fa_f32_f16>(@test_value(0) T) -> T |
| @must_use @const fn cos<N: num, T: fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T> |
| @must_use @const fn cosh<T: fa_f32_f16>(@test_value(0) T) -> T |
| @must_use @const fn cosh<N: num, T: fa_f32_f16>(@test_value(0) vec<N, T>) -> vec<N, T> |
| @must_use @const fn countLeadingZeros<T: iu32>(T) -> T |
| @must_use @const fn countLeadingZeros<N: num, T: iu32>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn countOneBits<T: iu32>(T) -> T |
| @must_use @const fn countOneBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn countTrailingZeros<T: iu32>(T) -> T |
| @must_use @const fn countTrailingZeros<N: num, T: iu32>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn cross<T: fa_f32_f16>(vec3<T>, vec3<T>) -> vec3<T> |
| @must_use @const fn degrees<T: fa_f32_f16>(T) -> T |
| @must_use @const fn degrees<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn determinant<N: num, T: fa_f32_f16>(mat<N, N, T>) -> T |
| @must_use @const fn distance<T: fa_f32_f16>(T, T) -> T |
| @must_use @const fn distance<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> T |
| @must_use @const fn dot<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> T |
| @must_use @const fn dot4I8Packed(u32, u32) -> i32 |
| @must_use @const fn dot4U8Packed(u32, u32) -> u32 |
| @must_use @stage("fragment") fn dpdx(f32) -> f32 |
| @must_use @stage("fragment") fn dpdx<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn dpdxCoarse(f32) -> f32 |
| @must_use @stage("fragment") fn dpdxCoarse<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn dpdxFine(f32) -> f32 |
| @must_use @stage("fragment") fn dpdxFine<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn dpdy(f32) -> f32 |
| @must_use @stage("fragment") fn dpdy<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn dpdyCoarse(f32) -> f32 |
| @must_use @stage("fragment") fn dpdyCoarse<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn dpdyFine(f32) -> f32 |
| @must_use @stage("fragment") fn dpdyFine<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @const fn exp<T: fa_f32_f16>(T) -> T |
| @must_use @const fn exp<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn exp2<T: fa_f32_f16>(T) -> T |
| @must_use @const fn exp2<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn extractBits<T: iu32>(T, u32, u32) -> T |
| @must_use @const fn extractBits<N: num, T: iu32>(vec<N, T>, u32, u32) -> vec<N, T> |
| @must_use @const fn faceForward<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn firstLeadingBit<T: iu32>(T) -> T |
| @must_use @const fn firstLeadingBit<N: num, T: iu32>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn firstTrailingBit<T: iu32>(T) -> T |
| @must_use @const fn firstTrailingBit<N: num, T: iu32>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn floor<T: fa_f32_f16>(@test_value(1.5) T) -> T |
| @must_use @const fn floor<N: num, T: fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> |
| @must_use @const fn fma<T: fa_f32_f16>(T, T, T) -> T |
| @must_use @const fn fma<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn fract<T: fa_f32_f16>(@test_value(1.25) T) -> T |
| @must_use @const fn fract<N: num, T: fa_f32_f16>(@test_value(1.25) vec<N, T>) -> vec<N, T> |
| @must_use @const fn frexp<T: fa_f32_f16>(T) -> __frexp_result<T> |
| @must_use @const fn frexp<N: num, T: fa_f32_f16>(vec<N, T>) -> __frexp_result_vec<N, T> |
| @must_use @stage("fragment") fn fwidth(f32) -> f32 |
| @must_use @stage("fragment") fn fwidth<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn fwidthCoarse(f32) -> f32 |
| @must_use @stage("fragment") fn fwidthCoarse<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @stage("fragment") fn fwidthFine(f32) -> f32 |
| @must_use @stage("fragment") fn fwidthFine<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @const fn insertBits<T: iu32>(T, T, u32, u32) -> T |
| @must_use @const fn insertBits<N: num, T: iu32>(vec<N, T>, vec<N, T>, u32, u32) -> vec<N, T> |
| @must_use @const fn inverseSqrt<T: fa_f32_f16>(T) -> T |
| @must_use @const fn inverseSqrt<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn ldexp<T: fa_f32_f16, U: ia_i32>(T, U) -> T |
| @must_use @const fn ldexp<N: num, T: fa_f32_f16, U: ia_i32>(vec<N, T>, vec<N, U>) -> vec<N, T> |
| @must_use @const fn length<T: fa_f32_f16>(@test_value(0.0) T) -> T |
| @must_use @const fn length<N: num, T: fa_f32_f16>(@test_value(0.0) vec<N, T>) -> T |
| @must_use @const fn log<T: fa_f32_f16>(T) -> T |
| @must_use @const fn log<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn log2<T: fa_f32_f16>(T) -> T |
| @must_use @const fn log2<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn max<T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const fn max<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn min<T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const fn min<N: num, T: fia_fiu32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn mix<T: fa_f32_f16>(T, T, T) -> T |
| @must_use @const fn mix<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn mix<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> |
| @must_use @const fn modf<T: fa_f32_f16>(@test_value(-1.5) T) -> __modf_result<T> |
| @must_use @const fn modf<N: num, T: fa_f32_f16>(@test_value(-1.5) vec<N, T>) -> __modf_result_vec<N, T> |
| @must_use @const fn normalize<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn pack2x16float(vec2<f32>) -> u32 |
| @must_use @const fn pack2x16snorm(vec2<f32>) -> u32 |
| @must_use @const fn pack2x16unorm(vec2<f32>) -> u32 |
| @must_use @const fn pack4x8snorm(vec4<f32>) -> u32 |
| @must_use @const fn pack4x8unorm(vec4<f32>) -> u32 |
| @must_use @const fn pack4xI8(vec4<i32>) -> u32 |
| @must_use @const fn pack4xU8(vec4<u32>) -> u32 |
| @must_use @const fn pack4xI8Clamp(vec4<i32>) -> u32 |
| @must_use @const fn pack4xU8Clamp(vec4<u32>) -> u32 |
| @must_use @const fn pow<T: fa_f32_f16>(T, T) -> T |
| @must_use @const fn pow<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn quantizeToF16(f32) -> f32 |
| @must_use @const fn quantizeToF16<N: num>(vec<N, f32>) -> vec<N, f32> |
| @must_use @const fn radians<T: fa_f32_f16>(T) -> T |
| @must_use @const fn radians<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn reflect<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const fn refract<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>, T) -> vec<N, T> |
| @must_use @const fn reverseBits<T: iu32>(T) -> T |
| @must_use @const fn reverseBits<N: num, T: iu32>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn round<T: fa_f32_f16>(@test_value(3.5) T) -> T |
| @must_use @const fn round<N: num, T: fa_f32_f16>(@test_value(3.5) vec<N, T>) -> vec<N, T> |
| @must_use @const fn saturate<T: fa_f32_f16>(@test_value(2) T) -> T |
| @must_use @const fn saturate<T: fa_f32_f16, N: num>(@test_value(2) vec<N, T>) -> vec<N, T> |
| @must_use @const("select_bool") fn select<T: scalar>(T, T, bool) -> T |
| @must_use @const("select_bool") fn select<T: scalar, N: num>(vec<N, T>, vec<N, T>, bool) -> vec<N, T> |
| @must_use @const("select_boolvec") fn select<N: num, T: scalar>(vec<N, T>, vec<N, T>, vec<N, bool>) -> vec<N, T> |
| @must_use @const fn sign<T: fia_fi32_f16>(T) -> T |
| @must_use @const fn sign<N: num, T: fia_fi32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn sin<T: fa_f32_f16>(@test_value(1.57079632679) T) -> T |
| @must_use @const fn sin<N: num, T: fa_f32_f16>(@test_value(1.57079632679) vec<N, T>) -> vec<N, T> |
| @must_use @const fn sinh<T: fa_f32_f16>(T) -> T |
| @must_use @const fn sinh<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn smoothstep<T: fa_f32_f16>(@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T |
| @must_use @const fn smoothstep<N: num, T: fa_f32_f16>(@test_value(2) vec<N, T>, @test_value(4) vec<N, T>, @test_value(3) vec<N, T>) -> vec<N, T> |
| @must_use @const fn sqrt<T: fa_f32_f16>(T) -> T |
| @must_use @const fn sqrt<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn step<T: fa_f32_f16>(T, T) -> T |
| @must_use @const fn step<N: num, T: fa_f32_f16>(vec<N, T>, vec<N, T>) -> vec<N, T> |
| @stage("compute") fn storageBarrier() |
| @must_use @const fn tan<T: fa_f32_f16>(T) -> T |
| @must_use @const fn tan<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn tanh<T: fa_f32_f16>(T) -> T |
| @must_use @const fn tanh<N: num, T: fa_f32_f16>(vec<N, T>) -> vec<N, T> |
| @must_use @const fn transpose<M: num, N: num, T: fa_f32_f16>(mat<M, N, T>) -> mat<N, M, T> |
| @must_use @const fn trunc<T: fa_f32_f16>(@test_value(1.5) T) -> T |
| @must_use @const fn trunc<N: num, T: fa_f32_f16>(@test_value(1.5) vec<N, T>) -> vec<N, T> |
| @must_use @const fn unpack2x16float(u32) -> vec2<f32> |
| @must_use @const fn unpack2x16snorm(u32) -> vec2<f32> |
| @must_use @const fn unpack2x16unorm(u32) -> vec2<f32> |
| @must_use @const fn unpack4x8snorm(u32) -> vec4<f32> |
| @must_use @const fn unpack4x8unorm(u32) -> vec4<f32> |
| @must_use @const fn unpack4xI8(u32) -> vec4<i32> |
| @must_use @const fn unpack4xU8(u32) -> vec4<u32> |
| @stage("compute") fn workgroupBarrier() |
| @must_use @stage("compute") fn workgroupUniformLoad<T>(ptr<workgroup, T, read_write>) -> T |
| |
| @stage("compute") fn textureBarrier() |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_1d<T>) -> u32 |
| @must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_1d<T>, level: L) -> u32 |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_2d<T>) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_2d<T>, level: L) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_2d_array<T>) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_2d_array<T>, level: L) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_3d<T>) -> vec3<u32> |
| @must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_3d<T>, level: L) -> vec3<u32> |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_cube<T>) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_cube<T>, level: L) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_cube_array<T>) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32, L: iu32>(texture: texture_cube_array<T>, level: L) -> vec2<u32> |
| @must_use fn textureDimensions<T: fiu32>(texture: texture_multisampled_2d<T>) -> vec2<u32> |
| @must_use fn textureDimensions(texture: texture_depth_2d) -> vec2<u32> |
| @must_use fn textureDimensions<L: iu32>(texture: texture_depth_2d, level: L) -> vec2<u32> |
| @must_use fn textureDimensions(texture: texture_depth_2d_array) -> vec2<u32> |
| @must_use fn textureDimensions<L: iu32>(texture: texture_depth_2d_array, level: L) -> vec2<u32> |
| @must_use fn textureDimensions(texture: texture_depth_cube) -> vec2<u32> |
| @must_use fn textureDimensions<L: iu32>(texture: texture_depth_cube, level: L) -> vec2<u32> |
| @must_use fn textureDimensions(texture: texture_depth_cube_array) -> vec2<u32> |
| @must_use fn textureDimensions<L: iu32>(texture: texture_depth_cube_array, level: L) -> vec2<u32> |
| @must_use fn textureDimensions(texture: texture_depth_multisampled_2d) -> vec2<u32> |
| @must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_1d<F, A>) -> u32 |
| @must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_2d<F, A>) -> vec2<u32> |
| @must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_2d_array<F, A>) -> vec2<u32> |
| @must_use fn textureDimensions<F: texel_format, A: access>(texture: texture_storage_3d<F, A>) -> vec3<u32> |
| @must_use fn textureDimensions(texture: texture_external) -> vec2<u32> |
| @must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>) -> vec4<T> |
| @must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_2d<T>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<T> |
| @must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<T> |
| @must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_2d_array<T>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<T> |
| @must_use fn textureGather<T: fiu32, C: iu32>(@const component: C, texture: texture_cube<T>, sampler: sampler, coords: vec3<f32>) -> vec4<T> |
| @must_use fn textureGather<T: fiu32, C: iu32, A: iu32>(@const component: C, texture: texture_cube_array<T>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<T> |
| @must_use fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> vec4<f32> |
| @must_use fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureGather<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32> |
| @must_use fn textureGather<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> vec4<f32> |
| @must_use fn textureGather<A: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32> |
| @must_use fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> vec4<f32> |
| @must_use fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> vec4<f32> |
| @must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> vec4<f32> |
| @must_use fn textureGatherCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> vec4<f32> |
| @must_use fn textureNumLayers<T: fiu32>(texture: texture_2d_array<T>) -> u32 |
| @must_use fn textureNumLayers<T: fiu32>(texture: texture_cube_array<T>) -> u32 |
| @must_use fn textureNumLayers(texture: texture_depth_2d_array) -> u32 |
| @must_use fn textureNumLayers(texture: texture_depth_cube_array) -> u32 |
| @must_use fn textureNumLayers<F: texel_format, A: access>(texture: texture_storage_2d_array<F, A>) -> u32 |
| @must_use fn textureNumLevels<T: fiu32>(texture: texture_1d<T>) -> u32 |
| @must_use fn textureNumLevels<T: fiu32>(texture: texture_2d<T>) -> u32 |
| @must_use fn textureNumLevels<T: fiu32>(texture: texture_2d_array<T>) -> u32 |
| @must_use fn textureNumLevels<T: fiu32>(texture: texture_3d<T>) -> u32 |
| @must_use fn textureNumLevels<T: fiu32>(texture: texture_cube<T>) -> u32 |
| @must_use fn textureNumLevels<T: fiu32>(texture: texture_cube_array<T>) -> u32 |
| @must_use fn textureNumLevels(texture: texture_depth_2d) -> u32 |
| @must_use fn textureNumLevels(texture: texture_depth_2d_array) -> u32 |
| @must_use fn textureNumLevels(texture: texture_depth_cube) -> u32 |
| @must_use fn textureNumLevels(texture: texture_depth_cube_array) -> u32 |
| @must_use fn textureNumSamples<T: fiu32>(texture: texture_multisampled_2d<T>) -> u32 |
| @must_use fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32 |
| @must_use @stage("fragment") fn textureSample(texture: texture_1d<f32>, sampler: sampler, coords: f32) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>) -> f32 |
| @must_use @stage("fragment") fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, @const offset: vec2<i32>) -> f32 |
| @must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A) -> f32 |
| @must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, @const offset: vec2<i32>) -> f32 |
| @must_use @stage("fragment") fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>) -> f32 |
| @must_use @stage("fragment") fn textureSample<A: iu32>(texture: texture_depth_cube_array, sampler: sampler, coords: vec3<f32>, array_index: A) -> f32 |
| @must_use @stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, bias: f32, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, bias: f32, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, bias: f32, @const offset: vec3<i32>) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, bias: f32) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleBias<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, bias: f32) -> vec4<f32> |
| @must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32 |
| @must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32 |
| @must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32 |
| @must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32 |
| @must_use @stage("fragment") fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 |
| @must_use @stage("fragment") fn textureSampleCompare<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32 |
| @must_use fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32) -> f32 |
| @must_use fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2<f32>, depth_ref: f32, @const offset: vec2<i32>) -> f32 |
| @must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32) -> f32 |
| @must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2<f32>, array_index: A, depth_ref: f32, @const offset: vec2<i32>) -> f32 |
| @must_use fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3<f32>, depth_ref: f32) -> f32 |
| @must_use fn textureSampleCompareLevel<A: iu32>(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3<f32>, array_index: A, depth_ref: f32) -> f32 |
| @must_use fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> |
| @must_use fn textureSampleGrad(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureSampleGrad<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> |
| @must_use fn textureSampleGrad<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, ddx: vec2<f32>, ddy: vec2<f32>, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> |
| @must_use fn textureSampleGrad(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>, @const offset: vec3<i32>) -> vec4<f32> |
| @must_use fn textureSampleGrad(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> |
| @must_use fn textureSampleGrad<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, ddx: vec3<f32>, ddy: vec3<f32>) -> vec4<f32> |
| @must_use fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32) -> vec4<f32> |
| @must_use fn textureSampleLevel(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>, level: f32, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureSampleLevel<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32) -> vec4<f32> |
| @must_use fn textureSampleLevel<A: iu32>(texture: texture_2d_array<f32>, sampler: sampler, coords: vec2<f32>, array_index: A, level: f32, @const offset: vec2<i32>) -> vec4<f32> |
| @must_use fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32> |
| @must_use fn textureSampleLevel(texture: texture_3d<f32>, sampler: sampler, coords: vec3<f32>, level: f32, @const offset: vec3<i32>) -> vec4<f32> |
| @must_use fn textureSampleLevel(texture: texture_cube<f32>, sampler: sampler, coords: vec3<f32>, level: f32) -> vec4<f32> |
| @must_use fn textureSampleLevel<A: iu32>(texture: texture_cube_array<f32>, sampler: sampler, coords: vec3<f32>, array_index: A, level: f32) -> vec4<f32> |
| @must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L) -> f32 |
| @must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_2d, sampler: sampler, coords: vec2<f32>, level: L, @const offset: vec2<i32>) -> f32 |
| @must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L) -> f32 |
| @must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_2d_array, sampler: sampler, coords: vec2<f32>, array_index: A, level: L, @const offset: vec2<i32>) -> f32 |
| @must_use fn textureSampleLevel<L: iu32>(texture: texture_depth_cube, sampler: sampler, coords: vec3<f32>, level: L) -> f32 |
| @must_use fn textureSampleLevel<A: iu32, L: iu32>(texture: texture_depth_cube_array,sampler: sampler, coords: vec3<f32>, array_index: A, level: L) -> f32 |
| @must_use fn textureSampleBaseClampToEdge(texture: texture_2d<f32>, sampler: sampler, coords: vec2<f32>) -> vec4<f32> |
| @must_use fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2<f32>) -> vec4<f32> |
| fn textureStore<C: iu32>(texture: texture_storage_1d<f32_texel_format, writable>, coords: C, value: vec4<f32>) |
| fn textureStore<C: iu32>(texture: texture_storage_2d<f32_texel_format, writable>, coords: vec2<C>, value: vec4<f32>) |
| fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<f32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<f32>) |
| fn textureStore<C: iu32>(texture: texture_storage_3d<f32_texel_format, writable>, coords: vec3<C>, value: vec4<f32>) |
| fn textureStore<C: iu32>(texture: texture_storage_1d<i32_texel_format, writable>, coords: C, value: vec4<i32>) |
| fn textureStore<C: iu32>(texture: texture_storage_2d<i32_texel_format, writable>, coords: vec2<C>, value: vec4<i32>) |
| fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<i32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<i32>) |
| fn textureStore<C: iu32>(texture: texture_storage_3d<i32_texel_format, writable>, coords: vec3<C>, value: vec4<i32>) |
| fn textureStore<C: iu32>(texture: texture_storage_1d<u32_texel_format, writable>, coords: C, value: vec4<u32>) |
| fn textureStore<C: iu32>(texture: texture_storage_2d<u32_texel_format, writable>, coords: vec2<C>, value: vec4<u32>) |
| fn textureStore<C: iu32, A: iu32>(texture: texture_storage_2d_array<u32_texel_format, writable>, coords: vec2<C>, array_index: A, value: vec4<u32>) |
| fn textureStore<C: iu32>(texture: texture_storage_3d<u32_texel_format, writable>, coords: vec3<C>, value: vec4<u32>) |
| @must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_1d<T>, coords: C, level: L) -> vec4<T> |
| @must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_2d<T>, coords: vec2<C>, level: L) -> vec4<T> |
| @must_use fn textureLoad<T: fiu32, C: iu32, A: iu32, L: iu32>(texture: texture_2d_array<T>, coords: vec2<C>, array_index: A, level: L) -> vec4<T> |
| @must_use fn textureLoad<T: fiu32, C: iu32, L: iu32>(texture: texture_3d<T>, coords: vec3<C>, level: L) -> vec4<T> |
| @must_use fn textureLoad<T: fiu32, C: iu32, S: iu32>(texture: texture_multisampled_2d<T>, coords: vec2<C>, sample_index: S) -> vec4<T> |
| @must_use fn textureLoad<C: iu32, L: iu32>(texture: texture_depth_2d, coords: vec2<C>, level: L) -> f32 |
| @must_use fn textureLoad<C: iu32, A: iu32, L: iu32>(texture: texture_depth_2d_array, coords: vec2<C>, array_index: A, level: L) -> f32 |
| @must_use fn textureLoad<C: iu32, S: iu32>(texture: texture_depth_multisampled_2d, coords: vec2<C>, sample_index: S) -> f32 |
| @must_use fn textureLoad<C: iu32>(texture: texture_external, coords: vec2<C>) -> vec4<f32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<f32_texel_format, readable>, coords: C) -> vec4<f32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<i32_texel_format, readable>, coords: C) -> vec4<i32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_1d<u32_texel_format, readable>, coords: C) -> vec4<u32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<f32_texel_format, readable>, coords: vec2<C>) -> vec4<f32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<i32_texel_format, readable>, coords: vec2<C>) -> vec4<i32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_2d<u32_texel_format, readable>, coords: vec2<C>) -> vec4<u32> |
| @must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<f32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<f32> |
| @must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<i32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<i32> |
| @must_use fn textureLoad<C: iu32, A: iu32>(texture: texture_storage_2d_array<u32_texel_format, readable>, coords: vec2<C>, array_index: A) -> vec4<u32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<f32_texel_format, readable>, coords: vec3<C>) -> vec4<f32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<i32_texel_format, readable>, coords: vec3<C>) -> vec4<i32> |
| @must_use fn textureLoad<C: iu32>(texture: texture_storage_3d<u32_texel_format, readable>, coords: vec3<C>) -> vec4<u32> |
| |
| @stage("fragment", "compute") fn atomicLoad<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>) -> T |
| @stage("fragment", "compute") fn atomicStore<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) |
| @stage("fragment", "compute") fn atomicAdd<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicSub<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicMax<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicMin<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicAnd<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicOr<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicXor<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicExchange<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T) -> T |
| @stage("fragment", "compute") fn atomicCompareExchangeWeak<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T> |
| |
| @must_use @stage("compute") fn subgroupBallot() -> vec4<u32> |
| @must_use @stage("compute") fn subgroupBroadcast<T: fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T |
| @must_use @stage("compute") fn subgroupBroadcast<N: num, T: fiu32_f16>(value: vec<N, T>, @const sourceLaneIndex: u32) -> vec<N, T> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Value constructors // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // Zero value constructors |
| @must_use @const("Zero") ctor i32() -> i32 |
| @must_use @const("Zero") ctor u32() -> u32 |
| @must_use @const("Zero") ctor f32() -> f32 |
| @must_use @const("Zero") ctor f16() -> f16 |
| @must_use @const("Zero") ctor bool() -> bool |
| @must_use @const("Zero") ctor vec2() -> vec2<ia> |
| @must_use @const("Zero") ctor vec3() -> vec3<ia> |
| @must_use @const("Zero") ctor vec4() -> vec4<ia> |
| @must_use @const("Zero") ctor vec2<T: concrete_scalar>() -> vec2<T> |
| @must_use @const("Zero") ctor vec3<T: concrete_scalar>() -> vec3<T> |
| @must_use @const("Zero") ctor vec4<T: concrete_scalar>() -> vec4<T> |
| @must_use @const("Zero") ctor mat2x2<T: f32_f16>() -> mat2x2<T> |
| @must_use @const("Zero") ctor mat2x3<T: f32_f16>() -> mat2x3<T> |
| @must_use @const("Zero") ctor mat2x4<T: f32_f16>() -> mat2x4<T> |
| @must_use @const("Zero") ctor mat3x2<T: f32_f16>() -> mat3x2<T> |
| @must_use @const("Zero") ctor mat3x3<T: f32_f16>() -> mat3x3<T> |
| @must_use @const("Zero") ctor mat3x4<T: f32_f16>() -> mat3x4<T> |
| @must_use @const("Zero") ctor mat4x2<T: f32_f16>() -> mat4x2<T> |
| @must_use @const("Zero") ctor mat4x3<T: f32_f16>() -> mat4x3<T> |
| @must_use @const("Zero") ctor mat4x4<T: f32_f16>() -> mat4x4<T> |
| |
| // Identity constructors |
| @must_use @const("Identity") ctor i32(i32) -> i32 |
| @must_use @const("Identity") ctor u32(u32) -> u32 |
| @must_use @const("Identity") ctor f32(f32) -> f32 |
| @must_use @const("Identity") ctor f16(f16) -> f16 |
| @must_use @const("Identity") ctor bool(bool) -> bool |
| @must_use @const("Identity") ctor vec2<T: scalar>(vec2<T>) -> vec2<T> |
| @must_use @const("Identity") ctor vec3<T: scalar>(vec3<T>) -> vec3<T> |
| @must_use @const("Identity") ctor vec4<T: scalar>(vec4<T>) -> vec4<T> |
| @must_use @const("Identity") ctor mat2x2<T: f32_f16>(mat2x2<T>) -> mat2x2<T> |
| @must_use @const("Identity") ctor mat2x3<T: f32_f16>(mat2x3<T>) -> mat2x3<T> |
| @must_use @const("Identity") ctor mat2x4<T: f32_f16>(mat2x4<T>) -> mat2x4<T> |
| @must_use @const("Identity") ctor mat3x2<T: f32_f16>(mat3x2<T>) -> mat3x2<T> |
| @must_use @const("Identity") ctor mat3x3<T: f32_f16>(mat3x3<T>) -> mat3x3<T> |
| @must_use @const("Identity") ctor mat3x4<T: f32_f16>(mat3x4<T>) -> mat3x4<T> |
| @must_use @const("Identity") ctor mat4x2<T: f32_f16>(mat4x2<T>) -> mat4x2<T> |
| @must_use @const("Identity") ctor mat4x3<T: f32_f16>(mat4x3<T>) -> mat4x3<T> |
| @must_use @const("Identity") ctor mat4x4<T: f32_f16>(mat4x4<T>) -> mat4x4<T> |
| |
| // Vector constructors (splat) |
| @must_use @const("VecSplat") ctor vec2<T: scalar>(T) -> vec2<T> |
| @must_use @const("VecSplat") ctor vec3<T: scalar>(T) -> vec3<T> |
| @must_use @const("VecSplat") ctor vec4<T: scalar>(T) -> vec4<T> |
| |
| // Vector constructors (scalar) |
| @must_use @const("VecInitS") ctor vec2<T: scalar>(x: T, y: T) -> vec2<T> |
| @must_use @const("VecInitS") ctor vec3<T: scalar>(x: T, y: T, z: T) -> vec3<T> |
| @must_use @const("VecInitS") ctor vec4<T: scalar>(x: T, y: T, z: T, w: T) -> vec4<T> |
| |
| // Vector constructors (mixed) |
| @must_use @const("VecInitM") ctor vec3<T: scalar>(xy: vec2<T>, z: T) -> vec3<T> |
| @must_use @const("VecInitM") ctor vec3<T: scalar>(x: T, yz: vec2<T>) -> vec3<T> |
| @must_use @const("VecInitM") ctor vec4<T: scalar>(xy: vec2<T>, z: T, w: T) -> vec4<T> |
| @must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, yz: vec2<T>, w: T) -> vec4<T> |
| @must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, y: T, zw: vec2<T>) -> vec4<T> |
| @must_use @const("VecInitM") ctor vec4<T: scalar>(xy: vec2<T>, zw: vec2<T>) -> vec4<T> |
| @must_use @const("VecInitM") ctor vec4<T: scalar>(xyz: vec3<T>, w: T) -> vec4<T> |
| @must_use @const("VecInitM") ctor vec4<T: scalar>(x: T, zyw: vec3<T>) -> vec4<T> |
| |
| // Matrix constructors (scalar) |
| @must_use @const("MatInitS") |
| ctor mat2x2<T: fa_f32_f16>(T, T, |
| T, T) -> mat2x2<T> |
| @must_use @const("MatInitS") |
| ctor mat2x3<T: fa_f32_f16>(T, T, T, |
| T, T, T) -> mat2x3<T> |
| @must_use @const("MatInitS") |
| ctor mat2x4<T: fa_f32_f16>(T, T, T, T, |
| T, T, T, T) -> mat2x4<T> |
| @must_use @const("MatInitS") |
| ctor mat3x2<T: fa_f32_f16>(T, T, |
| T, T, |
| T, T) -> mat3x2<T> |
| @must_use @const("MatInitS") |
| ctor mat3x3<T: fa_f32_f16>(T, T, T, |
| T, T, T, |
| T, T, T) -> mat3x3<T> |
| @must_use @const("MatInitS") |
| ctor mat3x4<T: fa_f32_f16>(T, T, T, T, |
| T, T, T, T, |
| T, T, T, T) -> mat3x4<T> |
| @must_use @const("MatInitS") |
| ctor mat4x2<T: fa_f32_f16>(T, T, |
| T, T, |
| T, T, |
| T, T) -> mat4x2<T> |
| @must_use @const("MatInitS") |
| ctor mat4x3<T: fa_f32_f16>(T, T, T, |
| T, T, T, |
| T, T, T, |
| T, T, T) -> mat4x3<T> |
| @must_use @const("MatInitS") |
| ctor mat4x4<T: fa_f32_f16>(T, T, T, T, |
| T, T, T, T, |
| T, T, T, T, |
| T, T, T, T) -> mat4x4<T> |
| |
| // Matrix constructors (column vectors) |
| @must_use @const("MatInitV") ctor mat2x2<T: fa_f32_f16>(vec2<T>, vec2<T>) -> mat2x2<T> |
| @must_use @const("MatInitV") ctor mat2x3<T: fa_f32_f16>(vec3<T>, vec3<T>) -> mat2x3<T> |
| @must_use @const("MatInitV") ctor mat2x4<T: fa_f32_f16>(vec4<T>, vec4<T>) -> mat2x4<T> |
| @must_use @const("MatInitV") ctor mat3x2<T: fa_f32_f16>(vec2<T>, vec2<T>, vec2<T>) -> mat3x2<T> |
| @must_use @const("MatInitV") ctor mat3x3<T: fa_f32_f16>(vec3<T>, vec3<T>, vec3<T>) -> mat3x3<T> |
| @must_use @const("MatInitV") ctor mat3x4<T: fa_f32_f16>(vec4<T>, vec4<T>, vec4<T>) -> mat3x4<T> |
| @must_use @const("MatInitV") ctor mat4x2<T: fa_f32_f16>(vec2<T>, vec2<T>, vec2<T>, vec2<T>) -> mat4x2<T> |
| @must_use @const("MatInitV") ctor mat4x3<T: fa_f32_f16>(vec3<T>, vec3<T>, vec3<T>, vec3<T>) -> mat4x3<T> |
| @must_use @const("MatInitV") ctor mat4x4<T: fa_f32_f16>(vec4<T>, vec4<T>, vec4<T>, vec4<T>) -> mat4x4<T> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Value conversions // |
| //////////////////////////////////////////////////////////////////////////////// |
| @must_use @const conv f32<T: scalar_no_f32>(T) -> f32 |
| @must_use @const conv f16<T: scalar_no_f16>(T) -> f16 |
| @must_use @const conv i32<T: scalar_no_i32>(T) -> i32 |
| @must_use @const conv u32<T: scalar_no_u32>(T) -> u32 |
| @must_use @const conv bool<T: scalar_no_bool>(T) -> bool |
| |
| @must_use @const conv vec2<T: f32, U: scalar_no_f32>(vec2<U>) -> vec2<f32> |
| @must_use @const conv vec2<T: f16, U: scalar_no_f16>(vec2<U>) -> vec2<f16> |
| @must_use @const conv vec2<T: i32, U: scalar_no_i32>(vec2<U>) -> vec2<i32> |
| @must_use @const conv vec2<T: u32, U: scalar_no_u32>(vec2<U>) -> vec2<u32> |
| @must_use @const conv vec2<T: bool, U: scalar_no_bool>(vec2<U>) -> vec2<bool> |
| |
| @must_use @const conv vec3<T: f32, U: scalar_no_f32>(vec3<U>) -> vec3<f32> |
| @must_use @const conv vec3<T: f16, U: scalar_no_f16>(vec3<U>) -> vec3<f16> |
| @must_use @const conv vec3<T: i32, U: scalar_no_i32>(vec3<U>) -> vec3<i32> |
| @must_use @const conv vec3<T: u32, U: scalar_no_u32>(vec3<U>) -> vec3<u32> |
| @must_use @const conv vec3<T: bool, U: scalar_no_bool>(vec3<U>) -> vec3<bool> |
| |
| @must_use @const conv vec4<T: f32, U: scalar_no_f32>(vec4<U>) -> vec4<f32> |
| @must_use @const conv vec4<T: f16, U: scalar_no_f16>(vec4<U>) -> vec4<f16> |
| @must_use @const conv vec4<T: i32, U: scalar_no_i32>(vec4<U>) -> vec4<i32> |
| @must_use @const conv vec4<T: u32, U: scalar_no_u32>(vec4<U>) -> vec4<u32> |
| @must_use @const conv vec4<T: bool, U: scalar_no_bool>(vec4<U>) -> vec4<bool> |
| |
| @must_use @const conv mat2x2<T: f16>(mat2x2<f32>) -> mat2x2<f16> |
| @must_use @const conv mat2x2<T: f32>(mat2x2<f16>) -> mat2x2<f32> |
| @must_use @const conv mat2x3<T: f16>(mat2x3<f32>) -> mat2x3<f16> |
| @must_use @const conv mat2x3<T: f32>(mat2x3<f16>) -> mat2x3<f32> |
| @must_use @const conv mat2x4<T: f16>(mat2x4<f32>) -> mat2x4<f16> |
| @must_use @const conv mat2x4<T: f32>(mat2x4<f16>) -> mat2x4<f32> |
| @must_use @const conv mat3x2<T: f16>(mat3x2<f32>) -> mat3x2<f16> |
| @must_use @const conv mat3x2<T: f32>(mat3x2<f16>) -> mat3x2<f32> |
| @must_use @const conv mat3x3<T: f16>(mat3x3<f32>) -> mat3x3<f16> |
| @must_use @const conv mat3x3<T: f32>(mat3x3<f16>) -> mat3x3<f32> |
| @must_use @const conv mat3x4<T: f16>(mat3x4<f32>) -> mat3x4<f16> |
| @must_use @const conv mat3x4<T: f32>(mat3x4<f16>) -> mat3x4<f32> |
| @must_use @const conv mat4x2<T: f16>(mat4x2<f32>) -> mat4x2<f16> |
| @must_use @const conv mat4x2<T: f32>(mat4x2<f16>) -> mat4x2<f32> |
| @must_use @const conv mat4x3<T: f16>(mat4x3<f32>) -> mat4x3<f16> |
| @must_use @const conv mat4x3<T: f32>(mat4x3<f16>) -> mat4x3<f32> |
| @must_use @const conv mat4x4<T: f16>(mat4x4<f32>) -> mat4x4<f16> |
| @must_use @const conv mat4x4<T: f32>(mat4x4<f16>) -> mat4x4<f32> |
| |
| // Conversion from vec3 to internal __packed_vec3 type. |
| @must_use @const conv packedVec3<T: concrete_scalar>(vec3<T>) -> packedVec3<T> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Operators // |
| // // |
| // The operator declarations below declare all the unary and binary operators // |
| // supported by the WGSL language (with exception for address-of and // |
| // dereference unary operators). // |
| // // |
| // The syntax is almost identical to builtin functions, except we use 'op' // |
| // instead of 'fn'. The resolving rules are identical to builtins, which is // |
| // described in detail above. // |
| // // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Unary Operators // |
| //////////////////////////////////////////////////////////////////////////////// |
| @must_use @const op ! (bool) -> bool |
| @must_use @const op ! <N: num> (vec<N, bool>) -> vec<N, bool> |
| |
| @must_use @const op ~ <T: ia_iu32>(T) -> T |
| @must_use @const op ~ <T: ia_iu32, N: num> (vec<N, T>) -> vec<N, T> |
| |
| @must_use @const("UnaryMinus") op - <T: fia_fi32_f16>(T) -> T |
| @must_use @const("UnaryMinus") op - <T: fia_fi32_f16, N: num> (vec<N, T>) -> vec<N, T> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Binary Operators // |
| //////////////////////////////////////////////////////////////////////////////// |
| @must_use @const op + <T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const op + <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const op + <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T> |
| @must_use @const op + <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T> |
| @must_use @const op + <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> |
| |
| @must_use @const op - <T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const op - <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const op - <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T> |
| @must_use @const op - <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T> |
| @must_use @const op - <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, mat<N, M, T>) -> mat<N, M, T> |
| |
| @must_use @const("Multiply") op * <T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const("Multiply") op * <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const("Multiply") op * <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T> |
| @must_use @const("Multiply") op * <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T> |
| @must_use @const("Multiply") op * <T: fa_f32_f16, N: num, M: num> (T, mat<N, M, T>) -> mat<N, M, T> |
| @must_use @const("Multiply") op * <T: fa_f32_f16, N: num, M: num> (mat<N, M, T>, T) -> mat<N, M, T> |
| @must_use @const("MultiplyMatVec") op * <T: fa_f32_f16, C: num, R: num> (mat<C, R, T>, vec<C, T>) -> vec<R, T> |
| @must_use @const("MultiplyVecMat") op * <T: fa_f32_f16, C: num, R: num> (vec<R, T>, mat<C, R, T>) -> vec<C, T> |
| @must_use @const("MultiplyMatMat") op * <T: fa_f32_f16, K: num, C: num, R: num> (mat<K, R, T>, mat<C, K, T>) -> mat<C, R, T> |
| |
| @must_use @const op / <T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const op / <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const op / <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T> |
| @must_use @const op / <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T> |
| |
| @must_use @const op % <T: fia_fiu32_f16>(T, T) -> T |
| @must_use @const op % <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| @must_use @const op % <T: fia_fiu32_f16, N: num> (vec<N, T>, T) -> vec<N, T> |
| @must_use @const op % <T: fia_fiu32_f16, N: num> (T, vec<N, T>) -> vec<N, T> |
| |
| @must_use @const op ^ <T: ia_iu32>(T, T) -> T |
| @must_use @const op ^ <T: ia_iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| |
| @must_use @const op & (bool, bool) -> bool |
| @must_use @const op & <N: num> (vec<N, bool>, vec<N, bool>) -> vec<N, bool> |
| @must_use @const op & <T: ia_iu32>(T, T) -> T |
| @must_use @const op & <T: ia_iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| |
| @must_use @const op | (bool, bool) -> bool |
| @must_use @const op | <N: num> (vec<N, bool>, vec<N, bool>) -> vec<N, bool> |
| @must_use @const op | <T: ia_iu32>(T, T) -> T |
| @must_use @const op | <T: ia_iu32, N: num> (vec<N, T>, vec<N, T>) -> vec<N, T> |
| |
| @must_use @const op && (bool, bool) -> bool |
| @must_use @const op || (bool, bool) -> bool |
| |
| @must_use @const op == <T: scalar>(T, T) -> bool |
| @must_use @const op == <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool> |
| |
| @must_use @const op != <T: scalar>(T, T) -> bool |
| @must_use @const op != <T: scalar, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool> |
| |
| @must_use @const op < <T: fia_fiu32_f16>(T, T) -> bool |
| @must_use @const op < <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool> |
| |
| @must_use @const op > <T: fia_fiu32_f16>(T, T) -> bool |
| @must_use @const op > <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool> |
| |
| @must_use @const op <= <T: fia_fiu32_f16>(T, T) -> bool |
| @must_use @const op <= <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool> |
| |
| @must_use @const op >= <T: fia_fiu32_f16>(T, T) -> bool |
| @must_use @const op >= <T: fia_fiu32_f16, N: num> (vec<N, T>, vec<N, T>) -> vec<N, bool> |
| |
| @must_use @const op << <T: ia_iu32>(T, u32) -> T |
| @must_use @const op << <T: ia_iu32, N: num> (vec<N, T>, vec<N, u32>) -> vec<N, T> |
| |
| @must_use @const op >> <T: ia_iu32>(T, u32) -> T |
| @must_use @const op >> <T: ia_iu32, N: num> (vec<N, T>, vec<N, u32>) -> vec<N, T> |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Tint internal builtins // |
| //////////////////////////////////////////////////////////////////////////////// |
| @const("Identity") fn _tint_materialize<T>(T) -> T |
