github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

[hlsl-out] Implicitly transpose all matrices

Browse Source
This commit is contained in:
Connor Fitzgerald
2021-08-15 19:32:52 -04:00
committed by Dzmitry Malyshau
parent 91ea6e3d83
commit 73be8c7454
6 changed files with 35 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/back/hlsl/mod.rs
View File

@@ -5,6 +5,17 @@
//! - 5.1
//! - 6.0
//!
//! All matrix construction/deconstruction is row based in HLSL. This means that when
//! we construct a matrix from column vectors, our matrix will be implicitly transposed.
//! The inverse transposition happens when we call `[0]` to get the zeroth column vector.
//!
//! Because all of our matrices are implicitly transposed, we flip arguments to `mul`. `mat * vec`
//! becomes `vec * mat`, etc. This acts as the inverse transpose making the results identical.
//!
//! The only time we don't get this implicit transposition is when reading matrices from Uniforms/Push Constants.
//! To deal with this, we add `row_major` to all declarations of matrices in Uniforms/Push Constants.
//!
//! Finally because all of our matrices are transposed, if you use `mat3x4`, it'll become `float4x3` in HLSL.
mod conv;
mod help;

9
src/back/hlsl/storage.rs
View File

@@ -1,7 +1,6 @@
//! Logic related to `ByteAddressBuffer` operations.
//!
//! HLSL backend uses byte address buffers for all storage buffers in IR.
//! Matrices have to be transposed, because HLSL syntax implies row majority.
use super::{
super::{FunctionCtx, INDENT},
@@ -122,7 +121,7 @@ impl<W: fmt::Write> super::Writer<'_, W> {
} => {
write!(
self.out,
"transpose({}{}x{}(",
"{}{}x{}(",
crate::ScalarKind::Float.to_hlsl_str(width)?,
rows as u8,
columns as u8,
@@ -144,7 +143,7 @@ impl<W: fmt::Write> super::Writer<'_, W> {
(TypeResolution::Value(ty_inner), i * row_stride)
});
self.write_storage_load_sequence(module, var_handle, iter, func_ctx)?;
write!(self.out, "))")?;
write!(self.out, ")")?;
}
crate::TypeInner::Array {
base,
@@ -267,7 +266,7 @@ impl<W: fmt::Write> super::Writer<'_, W> {
let depth = indent + 1;
write!(
self.out,
"{}{}{}x{} {}{} = transpose(",
"{}{}{}x{} {}{} = ",
INDENT.repeat(indent + 1),
crate::ScalarKind::Float.to_hlsl_str(width)?,
rows as u8,
@@ -276,7 +275,7 @@ impl<W: fmt::Write> super::Writer<'_, W> {
depth,
)?;
self.write_store_value(module, &value, func_ctx)?;
writeln!(self.out, ");")?;
writeln!(self.out, ";")?;
// then iterate the stores
let row_stride = width as u32 * columns as u32;
for i in 0..rows as u32 {

13
src/back/hlsl/writer.rs
View File

@@ -640,6 +640,10 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
}
}
if let TypeInner::Matrix { .. } = module.types[ty].inner {
write!(self.out, "row_major ")?;
}
// Write the member type and name
self.write_type(module, ty)?;
write!(
@@ -700,12 +704,14 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
} => {
// The IR supports only float matrix
// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-matrix
// Because of the implicit transpose all matrices have in HLSL, we need to tranpose the size as well.
write!(
self.out,
"{}{}x{}",
crate::ScalarKind::Float.to_hlsl_str(width)?,
back::vector_size_str(columns),
back::vector_size_str(rows),
back::vector_size_str(columns),
)?;
}
TypeInner::Image {
@@ -1302,10 +1308,11 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
.inner_with(&module.types)
.is_matrix() =>
{
// We intentionally flip the order of multiplication as our matrices are implicitly transposed.
write!(self.out, "mul(")?;
self.write_expr(module, left, func_ctx)?;
write!(self.out, ", ")?;
self.write_expr(module, right, func_ctx)?;
write!(self.out, ", ")?;
self.write_expr(module, left, func_ctx)?;
write!(self.out, ")")?;
}
Expression::Binary { op, left, right } => {

6
tests/out/hlsl/access.hlsl
View File

@@ -19,14 +19,14 @@ float4 foo(VertexInput_foo vertexinput_foo) : SV_Position
float baz = foo1;
foo1 = 1.0;
float4x4 matrix1 = transpose(float4x4(asfloat(bar.Load4(0+0)), asfloat(bar.Load4(0+16)), asfloat(bar.Load4(0+32)), asfloat(bar.Load4(0+48))));
float4x4 matrix1 = float4x4(asfloat(bar.Load4(0+0)), asfloat(bar.Load4(0+16)), asfloat(bar.Load4(0+32)), asfloat(bar.Load4(0+48)));
uint2 arr[2] = {asuint(bar.Load2(72+0)), asuint(bar.Load2(72+8))};
float4 _expr13 = asfloat(bar.Load4(48+0));
float b = _expr13.x;
int a = asint(bar.Load((((NagaBufferLengthRW(bar) - 88) / 4) - 2u)*4+88));
bar.Store(8+16+0, asuint(1.0));
{
float4x4 _value2 = transpose(float4x4(float4(0.0.xxxx), float4(1.0.xxxx), float4(2.0.xxxx), float4(3.0.xxxx)));
float4x4 _value2 = float4x4(float4(0.0.xxxx), float4(1.0.xxxx), float4(2.0.xxxx), float4(3.0.xxxx));
bar.Store4(0+0, asuint(_value2[0]));
bar.Store4(0+16, asuint(_value2[1]));
bar.Store4(0+32, asuint(_value2[2]));
@@ -43,7 +43,7 @@ float4 foo(VertexInput_foo vertexinput_foo) : SV_Position
}
c[(vertexinput_foo.vi1 + 1u)] = 42;
int value = c[vertexinput_foo.vi1];
return mul(matrix1, float4(int4(value.xxxx)));
return mul(float4(int4(value.xxxx)), matrix1);
}
[numthreads(1, 1, 1)]

6
tests/out/hlsl/shadow.hlsl
View File

@@ -6,7 +6,7 @@ struct Globals {
};
struct Light {
float4x4 proj;
row_major float4x4 proj;
float4 pos;
float4 color;
};
@@ -51,9 +51,9 @@ float4 fs_main(FragmentInput_fs_main fragmentinput_fs_main) : SV_Target0
break;
}
uint _expr19 = i;
Light light = {transpose(float4x4(asfloat(s_lights.Load4(_expr19*96+0+0+0)), asfloat(s_lights.Load4(_expr19*96+0+0+16)), asfloat(s_lights.Load4(_expr19*96+0+0+32)), asfloat(s_lights.Load4(_expr19*96+0+0+48)))), asfloat(s_lights.Load4(_expr19*96+0+64)), asfloat(s_lights.Load4(_expr19*96+0+80))};
Light light = {float4x4(asfloat(s_lights.Load4(_expr19*96+0+0+0)), asfloat(s_lights.Load4(_expr19*96+0+0+16)), asfloat(s_lights.Load4(_expr19*96+0+0+32)), asfloat(s_lights.Load4(_expr19*96+0+0+48))), asfloat(s_lights.Load4(_expr19*96+0+64)), asfloat(s_lights.Load4(_expr19*96+0+80))};
uint _expr22 = i;
const float _e25 = fetch_shadow(_expr22, mul(light.proj, fragmentinput_fs_main.position1));
const float _e25 = fetch_shadow(_expr22, mul(fragmentinput_fs_main.position1, light.proj));
float3 light_dir = normalize((light.pos.xyz - fragmentinput_fs_main.position1.xyz));
float diffuse = max(0.0, dot(normal, light_dir));
float3 _expr34 = color;

8
tests/out/hlsl/skybox.hlsl
View File

@@ -10,8 +10,8 @@ struct VertexOutput {
};
struct Data {
float4x4 proj_inv;
float4x4 view;
row_major float4x4 proj_inv;
row_major float4x4 view;
};
cbuffer r_data : register(b0) { Data r_data; }
@@ -41,8 +41,8 @@ VertexOutput vs_main(VertexInput_vs_main vertexinput_vs_main)
float4 _expr35 = r_data.view[2];
float3x3 inv_model_view = transpose(float3x3(_expr27.xyz, _expr31.xyz, _expr35.xyz));
float4x4 _expr40 = r_data.proj_inv;
float4 unprojected = mul(_expr40, pos);
const VertexOutput vertexoutput1 = { pos, mul(inv_model_view, unprojected.xyz) };
float4 unprojected = mul(pos, _expr40);
const VertexOutput vertexoutput1 = { pos, mul(unprojected.xyz, inv_model_view) };
return vertexoutput1;
}