// 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. //////////////////////////////////////////////////////////////////////////////// // WGSL intrinsic definition file // // // // This file is used to generate parts of the Tint IntrinsicTable, various // // enum definition files, as well as test .wgsl files. // //////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Enumerators // //////////////////////////////////////////////////////////////////////////////// // https://gpuweb.github.io/gpuweb/wgsl/#storage-class enum storage_class { function private workgroup uniform storage [[internal]] handle } // https://gpuweb.github.io/gpuweb/wgsl/#memory-access-mode enum access { read write read_write } // https://gpuweb.github.io/gpuweb/wgsl/#texel-formats enum texel_format { rgba8unorm rgba8snorm rgba8uint rgba8sint rgba16uint rgba16sint rgba16float r32uint r32sint r32float rg32uint rg32sint rg32float rgba32uint rgba32sint rgba32float } //////////////////////////////////////////////////////////////////////////////// // WGSL primitive types // //////////////////////////////////////////////////////////////////////////////// // https://gpuweb.github.io/gpuweb/wgsl/#plain-types-section type bool type f32 type i32 type u32 type vec2 type vec3 type vec4 [[display("vec{N}<{T}>")]] type vec [[display("mat{N}x{M}<{T}>")]] type mat type ptr type atomic type array type sampler type sampler_comparison type texture_1d type texture_2d type texture_2d_array type texture_3d type texture_cube type texture_cube_array type texture_multisampled_2d type texture_depth_2d type texture_depth_2d_array type texture_depth_cube type texture_depth_cube_array type texture_storage_1d type texture_storage_2d type texture_storage_2d_array type texture_storage_3d type texture_external //////////////////////////////////////////////////////////////////////////////// // Type matchers // // // // A type matcher that can match one or more types. // //////////////////////////////////////////////////////////////////////////////// match fiu32: f32 | i32 | u32 match iu32: i32 | u32 match scalar: f32 | i32 | u32 | bool //////////////////////////////////////////////////////////////////////////////// // 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: rgba8unorm | rgba8snorm | rgba16float | r32float | rg32float | rgba32float match i32_texel_format: rgba8sint | rgba16sint | r32sint | rg32sint | rgba32sint match u32_texel_format: rgba8uint | rgba16uint | r32uint | rg32uint | rgba32uint match read_or_write: read | write match function_private_workgroup: function | private | workgroup match workgroup_or_storage: workgroup | storage //////////////////////////////////////////////////////////////////////////////// // Intrinsic Functions // // // // The intrinsic function declarations below declare all the built-in // // functions supported by the WGSL language. This intrinsic 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 'open-types' and 'open-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'. // // // // An 'open-type' can be thought as a template type that is determined by the // // arguments to the intrinsic. // // // // * Open-type example without constraint: // // // // fn arrayLength(array) -> 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. // // // // * Open-type example with constraint: // // // // fn abs(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 an 'open-number' can be thought as a template number or // // enumerator that is determined by the arguments to the intrinsic. // // // // * Open-number example: // // // // fn dpdx(vec) -> vec // // // // 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: // // ------------------- // // // // Prior to matching an overload, all open-types are undefined. // // // // Open-types become closed-types (pinned to a fixed type) on the first // // attempt to match an argument to that open-type. // // Once open-types are closed, they remain that type for the rest of the // // overload evaluation. // // // // To better understand, let's consider the following hypothetical overload // // declaration: // // // // fn foo(T, T); // // // // T - is the open-type // // scalar - is a matcher for the types 'f32', 'i32', 'u32' or 'bool' // // (declared above) // // - declares the open-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. // // As the open-type T has not been closed yet, T is closed 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 open-type T is now closed, the argument type is compared // // against the value of the closed-type of T. If the types match, then // // the overload is still a candidate for matching, otherwise the // // overload is no longer considered. // // (3) If all the parameters matched, constraints on the open-types need // // to be checked next. If the closed-type does not match the 'match' // // constraint, then the overload is no longer considered. // // // // The algorithm for matching open-numbers is almost identical to open-types, // // except of course, they match against integer numbers or enumerators // // instead of types. // // // // // // * More examples: // // // // fn F() // // - Function called F. // // No open 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 intrinsic functions // // // // fn F(T) // // - Single parameter of unconstrained open-type T (any type) // // // // fn F(T) // // - Single parameter of constrained open-type T (must be a scalar) // // // // fn F(T) -> T // // - Single parameter of constrained open-type T (must be a one of fiu32) // // Return type matches parameter type // // // // fn F(vec) // // - Single parameter of vector type with open-number size N and element // // open-type T // // // // fn F(texture_storage_1d) // // - Single parameter of texture_storage_1d type with open-number // // access-control C, and of a texel format that is listed in // // f32_texel_format // // // //////////////////////////////////////////////////////////////////////////////// // https://gpuweb.github.io/gpuweb/wgsl/#builtin-functions fn abs(T) -> T fn abs(vec) -> vec fn acos(f32) -> f32 fn acos(vec) -> vec fn all(vec) -> bool fn any(vec) -> bool fn arrayLength(ptr, A>) -> u32 fn asin(f32) -> f32 fn asin(vec) -> vec fn atan(f32) -> f32 fn atan(vec) -> vec fn atan2(f32, f32) -> f32 fn atan2(vec, vec) -> vec fn ceil(f32) -> f32 fn ceil(vec) -> vec fn clamp(T, T, T) -> T fn clamp(vec, vec, vec) -> vec fn cos(f32) -> f32 fn cos(vec) -> vec fn cosh(f32) -> f32 fn cosh(vec) -> vec fn countOneBits(T) -> T fn countOneBits(vec) -> vec fn cross(vec3, vec3) -> vec3 fn determinant(mat) -> f32 fn distance(f32, f32) -> f32 fn distance(vec, vec) -> f32 fn dot(vec, vec) -> f32 [[stage("fragment")]] fn dpdx(f32) -> f32 [[stage("fragment")]] fn dpdx(vec) -> vec [[stage("fragment")]] fn dpdxCoarse(f32) -> f32 [[stage("fragment")]] fn dpdxCoarse(vec) -> vec [[stage("fragment")]] fn dpdxFine(f32) -> f32 [[stage("fragment")]] fn dpdxFine(vec) -> vec [[stage("fragment")]] fn dpdy(f32) -> f32 [[stage("fragment")]] fn dpdy(vec) -> vec [[stage("fragment")]] fn dpdyCoarse(f32) -> f32 [[stage("fragment")]] fn dpdyCoarse(vec) -> vec [[stage("fragment")]] fn dpdyFine(f32) -> f32 [[stage("fragment")]] fn dpdyFine(vec) -> vec fn exp(f32) -> f32 fn exp(vec) -> vec fn exp2(f32) -> f32 fn exp2(vec) -> vec fn faceForward(f32, f32, f32) -> f32 fn faceForward(vec, vec, vec) -> vec fn floor(f32) -> f32 fn floor(vec) -> vec fn fma(f32, f32, f32) -> f32 fn fma(vec, vec, vec) -> vec fn fract(f32) -> f32 fn fract(vec) -> vec fn frexp(f32, ptr) -> f32 fn frexp(vec, ptr, A>) -> vec [[stage("fragment")]] fn fwidth(f32) -> f32 [[stage("fragment")]] fn fwidth(vec) -> vec [[stage("fragment")]] fn fwidthCoarse(f32) -> f32 [[stage("fragment")]] fn fwidthCoarse(vec) -> vec [[stage("fragment")]] fn fwidthFine(f32) -> f32 [[stage("fragment")]] fn fwidthFine(vec) -> vec fn ignore(T) fn inverseSqrt(f32) -> f32 fn inverseSqrt(vec) -> vec fn isFinite(f32) -> bool fn isFinite(vec) -> vec fn isInf(f32) -> bool fn isInf(vec) -> vec fn isNan(f32) -> bool fn isNan(vec) -> vec fn isNormal(f32) -> bool fn isNormal(vec) -> vec fn ldexp(f32, T) -> f32 fn ldexp(vec, vec) -> vec fn length(f32) -> f32 fn length(vec) -> f32 fn log(f32) -> f32 fn log(vec) -> vec fn log2(f32) -> f32 fn log2(vec) -> vec fn max(T, T) -> T fn max(vec, vec) -> vec fn min(T, T) -> T fn min(vec, vec) -> vec fn mix(f32, f32, f32) -> f32 fn mix(vec, vec, vec) -> vec fn modf(f32, ptr) -> f32 fn modf(vec, ptr, A>) -> vec fn normalize(vec) -> vec fn pack2x16float(vec2) -> u32 fn pack2x16snorm(vec2) -> u32 fn pack2x16unorm(vec2) -> u32 fn pack4x8snorm(vec4) -> u32 fn pack4x8unorm(vec4) -> u32 fn pow(f32, f32) -> f32 fn pow(vec, vec) -> vec fn reflect(f32, f32) -> f32 fn reflect(vec, vec) -> vec fn reverseBits(T) -> T fn reverseBits(vec) -> vec fn round(f32) -> f32 fn round(vec) -> vec fn select(T, T, bool) -> T fn select(vec, vec, bool) -> vec fn select(vec, vec, vec) -> vec fn sign(f32) -> f32 fn sign(vec) -> vec fn sin(f32) -> f32 fn sin(vec) -> vec fn sinh(f32) -> f32 fn sinh(vec) -> vec fn smoothStep(f32, f32, f32) -> f32 fn smoothStep(vec, vec, vec) -> vec fn sqrt(f32) -> f32 fn sqrt(vec) -> vec fn step(f32, f32) -> f32 fn step(vec, vec) -> vec [[stage("compute")]] fn storageBarrier() fn tan(f32) -> f32 fn tan(vec) -> vec fn tanh(f32) -> f32 fn tanh(vec) -> vec fn transpose(mat) -> mat fn trunc(f32) -> f32 fn trunc(vec) -> vec fn unpack2x16float(u32) -> vec2 fn unpack2x16snorm(u32) -> vec2 fn unpack2x16unorm(u32) -> vec2 fn unpack4x8snorm(u32) -> vec4 fn unpack4x8unorm(u32) -> vec4 [[stage("compute")]] fn workgroupBarrier() fn textureDimensions(texture: texture_1d) -> i32 fn textureDimensions(texture: texture_2d) -> vec2 fn textureDimensions(texture: texture_2d, level: i32) -> vec2 fn textureDimensions(texture: texture_2d_array) -> vec2 fn textureDimensions(texture: texture_2d_array, level: i32) -> vec2 fn textureDimensions(texture: texture_3d) -> vec3 fn textureDimensions(texture: texture_3d, level: i32) -> vec3 fn textureDimensions(texture: texture_cube) -> vec2 fn textureDimensions(texture: texture_cube, level: i32) -> vec2 fn textureDimensions(texture: texture_cube_array) -> vec2 fn textureDimensions(texture: texture_cube_array, level: i32) -> vec2 fn textureDimensions(texture: texture_multisampled_2d) -> vec2 fn textureDimensions(texture: texture_depth_2d) -> vec2 fn textureDimensions(texture: texture_depth_2d, level: i32) -> vec2 fn textureDimensions(texture: texture_depth_2d_array) -> vec2 fn textureDimensions(texture: texture_depth_2d_array, level: i32) -> vec2 fn textureDimensions(texture: texture_depth_cube) -> vec2 fn textureDimensions(texture: texture_depth_cube, level: i32) -> vec2 fn textureDimensions(texture: texture_depth_cube_array) -> vec2 fn textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec2 fn textureDimensions(texture: texture_storage_1d) -> i32 fn textureDimensions(texture: texture_storage_2d) -> vec2 fn textureDimensions(texture: texture_storage_2d_array) -> vec2 fn textureDimensions(texture: texture_storage_3d) -> vec3 fn textureDimensions(texture: texture_external) -> vec2 fn textureNumLayers(texture: texture_2d_array) -> i32 fn textureNumLayers(texture: texture_cube_array) -> i32 fn textureNumLayers(texture: texture_depth_2d_array) -> i32 fn textureNumLayers(texture: texture_depth_cube_array) -> i32 fn textureNumLayers(texture: texture_storage_2d_array) -> i32 fn textureNumLevels(texture: texture_2d) -> i32 fn textureNumLevels(texture: texture_2d_array) -> i32 fn textureNumLevels(texture: texture_3d) -> i32 fn textureNumLevels(texture: texture_cube) -> i32 fn textureNumLevels(texture: texture_cube_array) -> i32 fn textureNumLevels(texture: texture_depth_2d) -> i32 fn textureNumLevels(texture: texture_depth_2d_array) -> i32 fn textureNumLevels(texture: texture_depth_cube) -> i32 fn textureNumLevels(texture: texture_depth_cube_array) -> i32 fn textureNumSamples(texture: texture_multisampled_2d) -> i32 [[stage("fragment")]] fn textureSample(texture: texture_1d, sampler: sampler, coords: f32) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2, offset: vec2) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, offset: vec2) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3, offset: vec3) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_cube, sampler: sampler, coords: vec3) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32) -> vec4 [[stage("fragment")]] fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2) -> f32 [[stage("fragment")]] fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2, offset: vec2) -> f32 [[stage("fragment")]] fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: i32) -> f32 [[stage("fragment")]] fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: i32, offset: vec2) -> f32 [[stage("fragment")]] fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> f32 [[stage("fragment")]] fn textureSample(texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: i32) -> f32 [[stage("fragment")]] fn textureSample(texture: texture_external, sampler: sampler, coords: vec2) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32, offset: vec2) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, bias: f32) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, bias: f32, offset: vec2) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32, offset: vec3) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_cube, sampler: sampler, coords: vec3, bias: f32) -> vec4 [[stage("fragment")]] fn textureSampleBias(texture: texture_cube_array, sampler: sampler, coords: vec3