mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-22 15:31:03 +01:00
143 lines
4.1 KiB
WebGPU Shading Language
143 lines
4.1 KiB
WebGPU Shading Language
// Common routines for timestamp normalization.
|
|
//
|
|
// This is split out into its own file so that the tests in `tests` can include
|
|
// it without including the normal endpoints and interface definitions.
|
|
|
|
/// 64-bit unsigned integer type.
|
|
///
|
|
/// We cannot rely on native 64-bit integers, so we define our own 64-bit
|
|
/// integer type as two 32-bit integers.
|
|
struct Uint64 {
|
|
/// Least significant word.
|
|
low: u32,
|
|
/// Most significant word.
|
|
high: u32,
|
|
}
|
|
|
|
/// 96-bit unsigned integer type.
|
|
struct Uint96 {
|
|
/// Least significant word.
|
|
low: u32,
|
|
/// Middle word.
|
|
mid: u32,
|
|
/// Most significant word.
|
|
high: u32,
|
|
}
|
|
|
|
/// Truncates a 96-bit number to a 64-bit number by discarding the upper 32 bits.
|
|
fn truncate_u96_to_u64(x: Uint96) -> Uint64 {
|
|
return Uint64(
|
|
x.low,
|
|
x.mid,
|
|
);
|
|
}
|
|
|
|
/// Returns the lower 16 bits of a 32-bit integer.
|
|
fn low(a: u32) -> u32 {
|
|
return a & 0xFFFF;
|
|
}
|
|
|
|
/// Returns the upper 16 bits of a 32-bit integer.
|
|
fn high(a: u32) -> u32 {
|
|
return a >> 16;
|
|
}
|
|
|
|
/// Combines two 16bit words into a single 32bit word.
|
|
/// `w1` is the upper 16 bits and `w0` is the lower 16 bits.
|
|
///
|
|
/// The high 16 bits of each argument are discarded.
|
|
fn u32_from_u16s(w1: u32, w0: u32) -> u32 {
|
|
return low(w1) << 16 | low(w0);
|
|
}
|
|
|
|
// Multiplies a 64-bit number by a 32-bit number and outputs a 96-bit result.
|
|
//
|
|
// The number of digits (bits) needed to represent the result of a multiplication
|
|
// is the sum of the number of input digits (bits). Since we are multiplying a
|
|
// 64-bit number by a 32-bit number, we need 96 bits to represent the result.
|
|
fn u64_mul_u32(a: Uint64, b: u32) -> Uint96 {
|
|
// Does not use any 64-bit operations and we don't have access to `mul(u32, u32) -> u64`
|
|
// operations, so we operate entirely on `mul(u16, u16) -> u32`.
|
|
|
|
// This implements standard "long multiplication" algorithm using 16-bit words.
|
|
// Each element in this diagram is a 16-bit word.
|
|
//
|
|
// a3 a2 a1 a0
|
|
// * b1 b0
|
|
// ----------------------------
|
|
// i0 = p00 p00
|
|
// i1 = p10 p10
|
|
// i2 = p20 p20
|
|
// i3 = p30 p30
|
|
// i4 = p01 p01
|
|
// i5 = p11 p11
|
|
// i6 = p21 p21
|
|
// i7 = p31 p31
|
|
// ----------------------------
|
|
// r6 r5 r4 r3 r2 r1 r0
|
|
|
|
// Decompose the 64-bit number into four 16-bit words.
|
|
let a0 = low(a.low);
|
|
let a1 = high(a.low);
|
|
let a2 = low(a.high);
|
|
let a3 = high(a.high);
|
|
|
|
// Decompose the 32-bit number into two 16-bit words.
|
|
let b0 = low(b);
|
|
let b1 = high(b);
|
|
|
|
// Each line represents one row in the diagram above.
|
|
let i0 = a0 * b0;
|
|
let i1 = a1 * b0;
|
|
let i2 = a2 * b0;
|
|
let i3 = a3 * b0;
|
|
let i4 = a0 * b1;
|
|
let i5 = a1 * b1;
|
|
let i6 = a2 * b1;
|
|
let i7 = a3 * b1;
|
|
|
|
// Each line represents one column in the diagram above.
|
|
//
|
|
// The high 16 bits of each column are the carry to the next column.
|
|
let r0 = low(i0);
|
|
let r1 = high(i0) + low(i1) + low(i4) + high(r0);
|
|
let r2 = high(i1) + low(i2) + high(i4) + low(i5) + high(r1);
|
|
let r3 = high(i2) + low(i3) + high(i5) + low(i6) + high(r2);
|
|
let r4 = high(i3) + high(i6) + low(i7) + high(r3);
|
|
let r5 = high(i7) + high(r4);
|
|
// The r5 carry will always be zero.
|
|
|
|
let out0 = u32_from_u16s(r1, r0);
|
|
let out1 = u32_from_u16s(r3, r2);
|
|
let out2 = u32_from_u16s(r5, r4);
|
|
|
|
return Uint96(out0, out1, out2);
|
|
}
|
|
|
|
// Shifts a 96-bit number right by a given number of bits.
|
|
//
|
|
// The shift is in the range [0, 32].
|
|
fn shift_right_96(x: Uint96, shift: u32) -> Uint96 {
|
|
// Shift wraps around at 32, which breaks the algorithm when
|
|
// either shift is 32 or inv_shift is 32.
|
|
if (shift == 0) {
|
|
return x;
|
|
}
|
|
if (shift == 32) {
|
|
return Uint96(x.mid, x.high, 0);
|
|
}
|
|
|
|
let inv_shift = 32 - shift;
|
|
|
|
let carry2 = x.high << inv_shift;
|
|
let carry1 = x.mid << inv_shift;
|
|
|
|
var out: Uint96;
|
|
|
|
out.high = x.high >> shift;
|
|
out.mid = (x.mid >> shift) | carry2;
|
|
out.low = (x.low >> shift) | carry1;
|
|
|
|
return out;
|
|
}
|