1
2struct PS_OUTPUT
3{
4    float4 Color : SV_Target0;
5};
6
7uniform int3    i3;
8uniform bool3   b3;
9uniform float3  f3;
10uniform uint3   u3;
11uniform double3 d3;
12
13uniform int    is;
14uniform bool   bs;
15uniform float  fs;
16uniform uint   us;
17uniform double ds;
18
19void Fn_F3(float3 x) { }
20void Fn_I3(int3 x) { }
21void Fn_U3(uint3 x) { }
22void Fn_B3(bool3 x) { }
23void Fn_D3(double3 x) { }
24
25// ----------- Test implicit conversions on function returns -----------
26float3  Fn_R_F3I(out float3 p) { p = i3; return i3; }
27float3  Fn_R_F3U(out float3 p) { p = u3; return u3; }
28float3  Fn_R_F3B(out float3 p) { p = b3; return b3; }
29float3  Fn_R_F3D(out float3 p) { p = d3; return d3; }  // valid, but loss of precision on downconversion.
30
31int3    Fn_R_I3U(out int3 p) { p = u3; return u3; }
32int3    Fn_R_I3B(out int3 p) { p = b3; return b3; }
33int3    Fn_R_I3F(out int3 p) { p = f3; return f3; }
34int3    Fn_R_I3D(out int3 p) { p = d3; return d3; }  // valid, but loss of precision on downconversion.
35
36uint3   Fn_R_U3I(out uint3 p) { p = i3; return i3; }
37uint3   Fn_R_U3F(out uint3 p) { p = f3; return f3; }
38uint3   Fn_R_U3B(out uint3 p) { p = b3; return b3; }
39uint3   Fn_R_U3D(out uint3 p) { p = d3; return d3; }  // valid, but loss of precision on downconversion.
40
41bool3   Fn_R_B3I(out bool3 p) { p = i3; return i3; }
42bool3   Fn_R_B3U(out bool3 p) { p = u3; return u3; }
43bool3   Fn_R_B3F(out bool3 p) { p = f3; return f3; }
44bool3   Fn_R_B3D(out bool3 p) { p = d3; return d3; }
45
46double3 Fn_R_D3I(out double3 p) { p = i3; return i3; }
47double3 Fn_R_D3U(out double3 p) { p = u3; return u3; }
48double3 Fn_R_D3B(out double3 p) { p = b3; return b3; }
49double3 Fn_R_D3F(out double3 p) { p = f3; return f3; }
50
51PS_OUTPUT main()
52{
53    // ----------- assignment conversions -----------
54    float3 r00 = i3;
55    float3 r01 = b3;
56    float3 r02 = u3;
57    float3 r03 = d3;  // valid, but loss of precision on downconversion.
58
59    int3   r10 = b3;
60    int3   r11 = u3;
61    int3   r12 = f3;
62    int3   r13 = d3;  // valid, but loss of precision on downconversion.
63
64    uint3  r20 = b3;
65    uint3  r21 = i3;
66    uint3  r22 = f3;
67    uint3  r23 = d3;  // valid, but loss of precision on downconversion.
68
69    bool3  r30 = i3;
70    bool3  r31 = u3;
71    bool3  r32 = f3;
72    bool3  r33 = d3;
73
74    double3 r40 = i3;
75    double3 r41 = u3;
76    double3 r42 = f3;
77    double3 r43 = b3;
78
79    // ----------- assign ops: vector times vector -----------
80    r00 *= i3;
81    r01 *= b3;
82    r02 *= u3;
83    r03 *= d3;  // valid, but loss of precision on downconversion.
84
85    r10 *= b3;
86    r11 *= u3;
87    r12 *= f3;
88    r13 *= d3;  // valid, but loss of precision on downconversion.
89
90    r20 *= b3;
91    r21 *= i3;
92    r22 *= f3;
93    r23 *= d3;  // valid, but loss of precision on downconversion.
94
95    // No mul operator for bools
96
97    r40 *= i3;
98    r41 *= u3;
99    r42 *= f3;
100    r43 *= b3;
101
102    // ----------- assign ops: vector times scalar -----------
103    r00 *= is;
104    r01 *= bs;
105    r02 *= us;
106    r03 *= ds;  // valid, but loss of precision on downconversion.
107
108    r10 *= bs;
109    r11 *= us;
110    r12 *= fs;
111    r13 *= ds;  // valid, but loss of precision on downconversion.
112
113    r20 *= bs;
114    r21 *= is;
115    r22 *= fs;
116    r23 *= ds;  // valid, but loss of precision on downconversion.
117
118    // No mul operator for bools
119
120    r40 *= is;
121    r41 *= us;
122    r42 *= fs;
123    r43 *= bs;
124
125
126#define FN_OVERLOADS 0 // change to 1 when overloads under promotions are in place
127
128#if FN_OVERLOADS
129    Fn_F3(i3);
130    Fn_F3(u3);
131    Fn_F3(f3);
132    Fn_F3(b3);
133    Fn_F3(d3);  // valid, but loss of precision on downconversion.
134
135    Fn_I3(i3);
136    Fn_I3(u3);
137    Fn_I3(f3);
138    Fn_I3(b3);
139    Fn_I3(d3);  // valid, but loss of precision on downconversion.
140
141    Fn_U3(i3);
142    Fn_U3(u3);
143    Fn_U3(f3);
144    Fn_U3(b3);
145    Fn_U3(d3);  // valid, but loss of precision on downconversion.
146
147    Fn_B3(i3);
148    Fn_B3(u3);
149    Fn_B3(f3);
150    Fn_B3(b3);
151    Fn_B3(d3);
152
153    Fn_D3(i3);
154    Fn_D3(u3);
155    Fn_D3(f3);
156    Fn_D3(b3);
157    Fn_D3(d3);
158
159    Fn_F3(i3.x);
160    Fn_F3(u3.x);
161    Fn_F3(f3.x);
162    Fn_F3(b3.x);
163    Fn_F3(d3.x);  // valid, but loss of precision on downconversion.
164
165    Fn_I3(i3.x);
166    Fn_I3(u3.x);
167    Fn_I3(f3.x);
168    Fn_I3(b3.x);
169    Fn_I3(d3.x);  // valid, but loss of precision on downconversion.
170
171    Fn_U3(i3.x);
172    Fn_U3(u3.x);
173    Fn_U3(f3.x);
174    Fn_U3(b3.x);
175    Fn_U3(d3.x);  // valid, but loss of precision on downconversion.
176
177    Fn_B3(i3.x);
178    Fn_B3(u3.x);
179    Fn_B3(f3.x);
180    Fn_B3(b3.x);
181    Fn_B3(d3.x);
182
183    Fn_D3(i3.x);
184    Fn_D3(u3.x);
185    Fn_D3(f3.x);
186    Fn_D3(b3.x);
187    Fn_D3(d3.x);
188#endif
189
190    const int   si = 3;
191    const float sf = 1.2;
192
193    int   c1 = si * sf;  // 3.6 (not 3!)
194    int   c2 = sf * si;  // 3.6 (not 3!)
195
196    float4 outval = float4(si * sf, sf*si, c1, c2);
197
198    PS_OUTPUT psout;
199    psout.Color = outval;
200    return psout;
201}
202