Skip to content

Remove matrix types row accessors for generated code #583

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Sergio0694 merged 4 commits into from
Sep 30, 2023
Merged

Remove matrix types row accessors for generated code #583

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
bf267a1
Remove implementation of HLSL matrix row accessors
Sergio0694 Sep 30, 2023
9285cf8
Update constant buffer codegen to be self-contained
Sergio0694 Sep 30, 2023
29d3be6
Add unit test for constant buffer with nested structures
Sergio0694 Sep 30, 2023
37818d8
Reorder D2D1PixelShader APIs to match interface
Sergio0694 Sep 30, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
64 changes: 32 additions & 32 deletions src/ComputeSharp.Core/Primitives/Bool/BoolMxN.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,10 +36,10 @@ public Bool1x1(bool m11)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref bool this[int row] => ref Unsafe.As<int, bool>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(bool) * row)));
public ref bool this[int row] => ref *(bool*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool1x1"/> instance.
Expand Down Expand Up @@ -184,10 +184,10 @@ public Bool1x2(bool m11, bool m12)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool2 this[int row] => ref Unsafe.As<int, Bool2>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool2) * row)));
public ref Bool2 this[int row] => ref *(Bool2*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool1x2"/> instance.
Expand Down Expand Up @@ -350,10 +350,10 @@ public Bool1x3(bool m11, bool m12, bool m13)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool3 this[int row] => ref Unsafe.As<int, Bool3>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool3) * row)));
public ref Bool3 this[int row] => ref *(Bool3*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool1x3"/> instance.
Expand Down Expand Up @@ -528,10 +528,10 @@ public Bool1x4(bool m11, bool m12, bool m13, bool m14)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool4 this[int row] => ref Unsafe.As<int, Bool4>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool4) * row)));
public ref Bool4 this[int row] => ref *(Bool4*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool1x4"/> instance.
Expand Down Expand Up @@ -703,10 +703,10 @@ public Bool2x1(bool m11, bool m21)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref bool this[int row] => ref Unsafe.As<int, bool>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(bool) * row)));
public ref bool this[int row] => ref *(bool*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool2x1"/> instance.
Expand Down Expand Up @@ -887,10 +887,10 @@ public Bool2x2(Bool2 row1, Bool2 row2)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool2 this[int row] => ref Unsafe.As<int, Bool2>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool2) * row)));
public ref Bool2 this[int row] => ref *(Bool2*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool2x2"/> instance.
Expand Down Expand Up @@ -1091,10 +1091,10 @@ public Bool2x3(Bool3 row1, Bool3 row2)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool3 this[int row] => ref Unsafe.As<int, Bool3>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool3) * row)));
public ref Bool3 this[int row] => ref *(Bool3*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool2x3"/> instance.
Expand Down Expand Up @@ -1321,10 +1321,10 @@ public Bool2x4(Bool4 row1, Bool4 row2)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool4 this[int row] => ref Unsafe.As<int, Bool4>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool4) * row)));
public ref Bool4 this[int row] => ref *(Bool4*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool2x4"/> instance.
Expand Down Expand Up @@ -1523,10 +1523,10 @@ public Bool3x1(bool m11, bool m21, bool m31)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref bool this[int row] => ref Unsafe.As<int, bool>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(bool) * row)));
public ref bool this[int row] => ref *(bool*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool3x1"/> instance.
Expand Down Expand Up @@ -1727,10 +1727,10 @@ public Bool3x2(Bool2 row1, Bool2 row2, Bool2 row3)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool2 this[int row] => ref Unsafe.As<int, Bool2>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool2) * row)));
public ref Bool2 this[int row] => ref *(Bool2*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool3x2"/> instance.
Expand Down Expand Up @@ -1964,10 +1964,10 @@ public Bool3x3(Bool3 row1, Bool3 row2, Bool3 row3)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool3 this[int row] => ref Unsafe.As<int, Bool3>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool3) * row)));
public ref Bool3 this[int row] => ref *(Bool3*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool3x3"/> instance.
Expand Down Expand Up @@ -2240,10 +2240,10 @@ public Bool3x4(Bool4 row1, Bool4 row2, Bool4 row3)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool4 this[int row] => ref Unsafe.As<int, Bool4>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool4) * row)));
public ref Bool4 this[int row] => ref *(Bool4*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool3x4"/> instance.
Expand Down Expand Up @@ -2475,10 +2475,10 @@ public Bool4x1(bool m11, bool m21, bool m31, bool m41)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref bool this[int row] => ref Unsafe.As<int, bool>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(bool) * row)));
public ref bool this[int row] => ref *(bool*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool4x1"/> instance.
Expand Down Expand Up @@ -2699,10 +2699,10 @@ public Bool4x2(Bool2 row1, Bool2 row2, Bool2 row3, Bool2 row4)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool2 this[int row] => ref Unsafe.As<int, Bool2>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool2) * row)));
public ref Bool2 this[int row] => ref *(Bool2*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool4x2"/> instance.
Expand Down Expand Up @@ -2969,10 +2969,10 @@ public Bool4x3(Bool3 row1, Bool3 row2, Bool3 row3, Bool3 row4)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool3 this[int row] => ref Unsafe.As<int, Bool3>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool3) * row)));
public ref Bool3 this[int row] => ref *(Bool3*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool4x3"/> instance.
Expand Down Expand Up @@ -3291,10 +3291,10 @@ public Bool4x4(Bool4 row1, Bool4 row2, Bool4 row3, Bool4 row4)
/// <param name="row">The row to access.</param>
/// <remarks>
/// <para>Unlike with vector types, these properties cannot validate in advance which combinations are writeable, so callers should ensure proper use.</para>
/// <para>Invoking this method with an invalid row argument results in undefined behavior.</para>
/// <para>This method is an intrinsic and can only be used within a shader on the GPU. Using it on the CPU is undefined behavior.</para>
/// </remarks>
[UnscopedRef]
public ref Bool4 this[int row] => ref Unsafe.As<int, Bool4>(ref Unsafe.AddByteOffset(ref this.m11, (nint)(uint)(sizeof(Bool4) * row)));
public ref Bool4 this[int row] => ref *(Bool4*)UndefinedData;

/// <summary>
/// Gets a swizzled reference to a specific sequence of items in the current <see cref="Bool4x4"/> instance.
Expand Down
Loading