1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=BUFFER):-shaderobj -vk
//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=BUFFER):-shaderobj
public struct Visibility
{
internal int x = 1;
public int y = 5;
int getX() { return x; }
}
//TEST_INPUT:ubuffer(data=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], stride=4):out,name=outputBuffer
RWStructuredBuffer<int> outputBuffer;
void test(inout uint index)
{
Visibility t1 = {}; // OK, initialized to {1,5} via ctor call.
// BUFFER: 1
outputBuffer[index++] = t1.getX();
// BUFFER-NEXT: 5
outputBuffer[index++] = t1.y;
Visibility t2 = {1}; // OK, initialized to {1,1} via ctor call.
// BUFFER-NEXT: 1
outputBuffer[index++] = t2.getX();
// BUFFER-NEXT: 1
outputBuffer[index++] = t2.y;
}
internal struct Visibility2
{
// Visibility3 type is considered as C-style struct.
// Because all members have the same visibility as the type.
// Therefore we will attempt the legacy fallback logic for
// initializer-list syntax.
// Note that c-style structs can still have init exprs on members.
internal int x;
internal int y = 2;
// compiler synthesizes:
// internal __init(int x, int y = 2);
}
internal void test2(inout uint index)
{
Visibility2 t = {3, 4}; // OK, initialized to {3,4} via ctor call.
// BUFFER-NEXT: 3
outputBuffer[index++] = t.x;
// BUFFER-NEXT: 4
outputBuffer[index++] = t.y;
Visibility2 t1 = {1}; // OK, initialized to {1,2} via ctor call.
// BUFFER-NEXT: 1
outputBuffer[index++] = t1.x;
// BUFFER-NEXT: 2
outputBuffer[index++] = t1.y;
Visibility2 t2 = {}; // OK, initialized to {0, 2} via legacy logic.
// BUFFER-NEXT: 0
outputBuffer[index++] = t2.x;
// BUFFER-NEXT: 2
outputBuffer[index++] = t2.y;
}
internal struct Visibility3
{
// Visibility4 type is considered as C-style struct.
// And we still synthesize a ctor for member initialization.
// Because Visibility4 has no public members, the synthesized
// ctor will take 0 arguments.
internal int x = 1;
internal int y = 2;
// compiler synthesizes:
// internal __init(int x = 1, int y = 2);
}
internal void test3(inout uint index)
{
Visibility3 t = {0, 0}; // OK, initialized to {0,0} via ctor call.
// BUFFER-NEXT: 0
outputBuffer[index++] = t.x;
// BUFFER-NEXT: 0
outputBuffer[index++] = t.y;
Visibility3 t1 = {3}; // OK, initialized to {3,2} via ctor call.
// BUFFER-NEXT: 3
outputBuffer[index++] = t1.x;
// BUFFER-NEXT: 2
outputBuffer[index++] = t1.y;
Visibility3 t2 = {}; // OK, initialized to {1,2} via ctor call.
// BUFFER-NEXT: 1
outputBuffer[index++] = t2.x;
// BUFFER-NEXT: 2
outputBuffer[index++] = t2.y;
}
[shader("compute")]
void computeMain()
{
uint index = 0;
test(index);
test2(index);
test3(index);
}
|
