diff --git a/src/intrinsics.def b/src/intrinsics.def new file mode 100644 index 0000000000..c069aa50cf --- /dev/null +++ b/src/intrinsics.def @@ -0,0 +1,505 @@ +// 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 + handle +} + +// https://gpuweb.github.io/gpuweb/wgsl/#memory-access-mode +enum access_control { + 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 +[[display("ptr<{T}>")]] type ptr // TODO(crbug.com/tint/846): Add access control +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 + +//////////////////////////////////////////////////////////////////////////////// +// 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(array) -> 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 +fn dpdx(f32) -> f32 +fn dpdx(vec) -> vec +fn dpdxCoarse(f32) -> f32 +fn dpdxCoarse(vec) -> vec +fn dpdxFine(f32) -> f32 +fn dpdxFine(vec) -> vec +fn dpdy(f32) -> f32 +fn dpdy(vec) -> vec +fn dpdyCoarse(f32) -> f32 +fn dpdyCoarse(vec) -> vec +fn dpdyFine(f32) -> f32 +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>) -> vec +fn fwidth(f32) -> f32 +fn fwidth(vec) -> vec +fn fwidthCoarse(f32) -> f32 +fn fwidthCoarse(vec) -> vec +fn fwidthFine(f32) -> f32 +fn fwidthFine(vec) -> vec +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>) -> 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, 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 +fn storageBarrier() +fn tan(f32) -> f32 +fn tan(vec) -> vec +fn tanh(f32) -> f32 +fn tanh(vec) -> vec +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 +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) -> vec3 +fn textureDimensions(texture: texture_cube, level: i32) -> vec3 +fn textureDimensions(texture: texture_cube_array) -> vec3 +fn textureDimensions(texture: texture_cube_array, level: i32) -> vec3 +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) -> vec3 +fn textureDimensions(texture: texture_depth_cube, level: i32) -> vec3 +fn textureDimensions(texture: texture_depth_cube_array) -> vec3 +fn textureDimensions(texture: texture_depth_cube_array, level: i32) -> vec3 +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 +fn textureSample(texture: texture_1d, sampler: sampler, coords: f32) -> vec4 +fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 +fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2, offset: vec2) -> vec4 +fn textureSample(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32) -> vec4 +fn textureSample(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, offset: vec2) -> vec4 +fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3) -> vec4 +fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3, offset: vec3) -> vec4 +fn textureSample(texture: texture_cube, sampler: sampler, coords: vec3) -> vec4 +fn textureSample(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32) -> vec4 +fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2) -> f32 +fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2, offset: vec2) -> f32 +fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: i32) -> f32 +fn textureSample(texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: i32, offset: vec2) -> f32 +fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> f32 +fn textureSample(texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: i32) -> f32 +fn textureSample(texture: texture_external, sampler: sampler, coords: vec2) -> vec4 +fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32) -> vec4 +fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32, offset: vec2) -> vec4 +fn textureSampleBias(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, bias: f32) -> vec4 +fn textureSampleBias(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, bias: f32, offset: vec2) -> vec4 +fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32) -> vec4 +fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32, offset: vec3) -> vec4 +fn textureSampleBias(texture: texture_cube, sampler: sampler, coords: vec3, bias: f32) -> vec4 +fn textureSampleBias(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32, bias: f32) -> vec4 +fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32) -> f32 +fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32, offset: vec2) -> f32 +fn textureSampleCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2, array_index: i32, depth_ref: f32) -> f32 +fn textureSampleCompare(texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2, array_index: i32, depth_ref: f32, offset: vec2) -> f32 +fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 +fn textureSampleCompare(texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: i32, depth_ref: f32) -> f32 +fn textureSampleGrad(texture: texture_2d, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 +fn textureSampleGrad(texture: texture_2d, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2, offset: vec2) -> vec4 +fn textureSampleGrad(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, ddx: vec2, ddy: vec2) -> vec4 +fn textureSampleGrad(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, ddx: vec2, ddy: vec2, offset: vec2) -> vec4 +fn textureSampleGrad(texture: texture_3d, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 +fn textureSampleGrad(texture: texture_3d, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3, offset: vec3) -> vec4 +fn textureSampleGrad(texture: texture_cube, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 +fn textureSampleGrad(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32, ddx: vec3, ddy: vec3) -> vec4 +fn textureSampleLevel(texture: texture_2d, sampler: sampler, coords: vec2, level: f32) -> vec4 +fn textureSampleLevel(texture: texture_2d, sampler: sampler, coords: vec2, level: f32, offset: vec2) -> vec4 +fn textureSampleLevel(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, level: f32) -> vec4 +fn textureSampleLevel(texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: i32, level: f32, offset: vec2) -> vec4 +fn textureSampleLevel(texture: texture_3d, sampler: sampler, coords: vec3, level: f32) -> vec4 +fn textureSampleLevel(texture: texture_3d, sampler: sampler, coords: vec3, level: f32, offset: vec3) -> vec4 +fn textureSampleLevel(texture: texture_cube, sampler: sampler, coords: vec3, level: f32) -> vec4 +fn textureSampleLevel(texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: i32, level: f32) -> vec4 +fn textureSampleLevel(texture: texture_depth_2d, sampler: sampler, coords: vec2, level: i32) -> f32 +fn textureSampleLevel(texture: texture_depth_2d, sampler: sampler, coords: vec2, level: i32, offset: vec2) -> f32 +fn textureSampleLevel(texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: i32, level: i32) -> f32 +fn textureSampleLevel(texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: i32, level: i32, offset: vec2) -> f32 +fn textureSampleLevel(texture: texture_depth_cube, sampler: sampler, coords: vec3, level: i32) -> f32 +fn textureSampleLevel(texture: texture_depth_cube_array,sampler: sampler, coords: vec3, array_index: i32, level: i32) -> f32 +fn textureSampleLevel(texture: texture_external, sampler: sampler, coords: vec2) -> vec4 +fn textureStore(texture: texture_storage_1d, coords: i32, value: vec4) +fn textureStore(texture: texture_storage_2d, coords: vec2, value: vec4) +fn textureStore(texture: texture_storage_2d_array, coords: vec2, array_index: i32, value: vec4) +fn textureStore(texture: texture_storage_3d, coords: vec3, value: vec4) +fn textureStore(texture: texture_storage_1d, coords: i32, value: vec4) +fn textureStore(texture: texture_storage_2d, coords: vec2, value: vec4) +fn textureStore(texture: texture_storage_2d_array, coords: vec2, array_index: i32, value: vec4) +fn textureStore(texture: texture_storage_3d, coords: vec3, value: vec4) +fn textureStore(texture: texture_storage_1d, coords: i32, value: vec4) +fn textureStore(texture: texture_storage_2d, coords: vec2, value: vec4) +fn textureStore(texture: texture_storage_2d_array, coords: vec2, array_index: i32, value: vec4) +fn textureStore(texture: texture_storage_3d, coords: vec3, value: vec4) +fn textureLoad(texture: texture_1d, coords: i32, level: i32) -> vec4 +fn textureLoad(texture: texture_2d, coords: vec2, level: i32) -> vec4 +fn textureLoad(texture: texture_2d_array, coords: vec2, array_index: i32, level: i32) -> vec4 +fn textureLoad(texture: texture_3d, coords: vec3, level: i32) -> vec4 +fn textureLoad(texture: texture_multisampled_2d, coords: vec2, sample_index: i32) -> vec4 +fn textureLoad(texture: texture_depth_2d, coords: vec2, level: i32) -> f32 +fn textureLoad(texture: texture_depth_2d_array, coords: vec2, array_index: i32, level: i32) -> f32 +fn textureLoad(texture: texture_storage_1d, coords: i32) -> vec4 +fn textureLoad(texture: texture_storage_2d, coords: vec2) -> vec4 +fn textureLoad(texture: texture_storage_2d_array, coords: vec2, array_index: i32) -> vec4 +fn textureLoad(texture: texture_storage_3d, coords: vec3) -> vec4 +fn textureLoad(texture: texture_storage_1d, coords: i32) -> vec4 +fn textureLoad(texture: texture_storage_2d, coords: vec2) -> vec4 +fn textureLoad(texture: texture_storage_2d_array, coords: vec2, array_index: i32) -> vec4 +fn textureLoad(texture: texture_storage_3d, coords: vec3) -> vec4 +fn textureLoad(texture: texture_storage_1d, coords: i32) -> vec4 +fn textureLoad(texture: texture_storage_2d, coords: vec2) -> vec4 +fn textureLoad(texture: texture_storage_2d_array, coords: vec2, array_index: i32) -> vec4 +fn textureLoad(texture: texture_storage_3d, coords: vec3) -> vec4 +fn textureLoad(texture: texture_external, coords: vec2) -> vec4