Jolt Physics
A multi core friendly Game Physics Engine
Loading...
Searching...
No Matches
HLSLToCPP.h
Go to the documentation of this file.
1// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
2// SPDX-FileCopyrightText: 2026 Jorrit Rouwe
3// SPDX-License-Identifier: MIT
4
5#pragma once
6
7JPH_NAMESPACE_BEGIN
8
11namespace HLSLToCPP {
12
13using std::sqrt;
14using std::min;
15using std::max;
16using std::round;
17
19// float2
21
22struct float2
23{
24 // Constructors
25 inline float2() = default;
26 constexpr float2(float inX, float inY) : x(inX), y(inY) { }
27 explicit constexpr float2(float inS) : x(inS), y(inS) { }
28
29 // Operators
30 constexpr float2 & operator += (const float2 &inRHS) { x += inRHS.x; y += inRHS.y; return *this; }
31 constexpr float2 & operator -= (const float2 &inRHS) { x -= inRHS.x; y -= inRHS.y; return *this; }
32 constexpr float2 & operator *= (float inRHS) { x *= inRHS; y *= inRHS; return *this; }
33 constexpr float2 & operator /= (float inRHS) { x /= inRHS; y /= inRHS; return *this; }
34 constexpr float2 & operator *= (const float2 &inRHS) { x *= inRHS.x; y *= inRHS.y; return *this; }
35 constexpr float2 & operator /= (const float2 &inRHS) { x /= inRHS.x; y /= inRHS.y; return *this; }
36
37 // Equality
38 constexpr bool operator == (const float2 &inRHS) const { return x == inRHS.x && y == inRHS.y; }
39 constexpr bool operator != (const float2 &inRHS) const { return !(*this == inRHS); }
40
41 // Component access
42 const float & operator [] (uint inIndex) const { return (&x)[inIndex]; }
43 float & operator [] (uint inIndex) { return (&x)[inIndex]; }
44
45 // Swizzling (note return value is const to prevent assignment to swizzled results)
46 const float2 swizzle_xy() const { return float2(x, y); }
47 const float2 swizzle_yx() const { return float2(y, x); }
48
49 float x, y;
50};
51
52// Operators
53constexpr float2 operator - (const float2 &inA) { return float2(-inA.x, -inA.y); }
54constexpr float2 operator + (const float2 &inA, const float2 &inB) { return float2(inA.x + inB.x, inA.y + inB.y); }
55constexpr float2 operator - (const float2 &inA, const float2 &inB) { return float2(inA.x - inB.x, inA.y - inB.y); }
56constexpr float2 operator * (const float2 &inA, const float2 &inB) { return float2(inA.x * inB.x, inA.y * inB.y); }
57constexpr float2 operator / (const float2 &inA, const float2 &inB) { return float2(inA.x / inB.x, inA.y / inB.y); }
58constexpr float2 operator * (const float2 &inA, float inS) { return float2(inA.x * inS, inA.y * inS); }
59constexpr float2 operator * (float inS, const float2 &inA) { return inA * inS; }
60constexpr float2 operator / (const float2 &inA, float inS) { return float2(inA.x / inS, inA.y / inS); }
61
62// Dot product
63constexpr float dot(const float2 &inA, const float2 &inB) { return inA.x * inB.x + inA.y * inB.y; }
64
65// Min value
66constexpr float2 min(const float2 &inA, const float2 &inB) { return float2(min(inA.x, inB.x), min(inA.y, inB.y)); }
67
68// Max value
69constexpr float2 max(const float2 &inA, const float2 &inB) { return float2(max(inA.x, inB.x), max(inA.y, inB.y)); }
70
71// Length
72inline float length(const float2 &inV) { return sqrt(dot(inV, inV)); }
73
74// Normalization
75inline float2 normalize(const float2 &inV) { return inV / length(inV); }
76
77// Rounding to int
78inline float2 round(const float2 &inV) { return float2(round(inV.x), round(inV.y)); }
79
81// float3
83
84struct uint3;
85
86struct float3
87{
88 // Constructors
89 inline float3() = default;
90 constexpr float3(const float2 &inV, float inZ) : x(inV.x), y(inV.y), z(inZ) { }
91 constexpr float3(float inX, float inY, float inZ) : x(inX), y(inY), z(inZ) { }
92 explicit constexpr float3(float inS) : x(inS), y(inS), z(inS) { }
93 explicit constexpr float3(const uint3 &inV);
94
95 // Operators
96 constexpr float3 & operator += (const float3 &inRHS) { x += inRHS.x; y += inRHS.y; z += inRHS.z; return *this; }
97 constexpr float3 & operator -= (const float3 &inRHS) { x -= inRHS.x; y -= inRHS.y; z -= inRHS.z; return *this; }
98 constexpr float3 & operator *= (float inRHS) { x *= inRHS; y *= inRHS; z *= inRHS; return *this; }
99 constexpr float3 & operator /= (float inRHS) { x /= inRHS; y /= inRHS; z /= inRHS; return *this; }
100 constexpr float3 & operator *= (const float3 &inRHS) { x *= inRHS.x; y *= inRHS.y; z *= inRHS.z; return *this; }
101 constexpr float3 & operator /= (const float3 &inRHS) { x /= inRHS.x; y /= inRHS.y; z /= inRHS.z; return *this; }
102
103 // Equality
104 constexpr bool operator == (const float3 &inRHS) const { return x == inRHS.x && y == inRHS.y && z == inRHS.z; }
105 constexpr bool operator != (const float3 &inRHS) const { return !(*this == inRHS); }
106
107 // Component access
108 const float & operator [] (uint inIndex) const { return (&x)[inIndex]; }
109 float & operator [] (uint inIndex) { return (&x)[inIndex]; }
110
111 // Swizzling (note return value is const to prevent assignment to swizzled results)
112 const float2 swizzle_xy() const { return float2(x, y); }
113 const float2 swizzle_yx() const { return float2(y, x); }
114 const float3 swizzle_xyz() const { return float3(x, y, z); }
115 const float3 swizzle_xzy() const { return float3(x, z, y); }
116 const float3 swizzle_yxz() const { return float3(y, x, z); }
117 const float3 swizzle_yzx() const { return float3(y, z, x); }
118 const float3 swizzle_zxy() const { return float3(z, x, y); }
119 const float3 swizzle_zyx() const { return float3(z, y, x); }
120
121 float x, y, z;
122};
123
124// Operators
125constexpr float3 operator - (const float3 &inA) { return float3(-inA.x, -inA.y, -inA.z); }
126constexpr float3 operator + (const float3 &inA, const float3 &inB) { return float3(inA.x + inB.x, inA.y + inB.y, inA.z + inB.z); }
127constexpr float3 operator - (const float3 &inA, const float3 &inB) { return float3(inA.x - inB.x, inA.y - inB.y, inA.z - inB.z); }
128constexpr float3 operator * (const float3 &inA, const float3 &inB) { return float3(inA.x * inB.x, inA.y * inB.y, inA.z * inB.z); }
129constexpr float3 operator / (const float3 &inA, const float3 &inB) { return float3(inA.x / inB.x, inA.y / inB.y, inA.z / inB.z); }
130constexpr float3 operator * (const float3 &inA, float inS) { return float3(inA.x * inS, inA.y * inS, inA.z * inS); }
131constexpr float3 operator * (float inS, const float3 &inA) { return inA * inS; }
132constexpr float3 operator / (const float3 &inA, float inS) { return float3(inA.x / inS, inA.y / inS, inA.z / inS); }
133
134// Dot product
135constexpr float dot(const float3 &inA, const float3 &inB) { return inA.x * inB.x + inA.y * inB.y + inA.z * inB.z; }
136
137// Min value
138constexpr float3 min(const float3 &inA, const float3 &inB) { return float3(min(inA.x, inB.x), min(inA.y, inB.y), min(inA.z, inB.z)); }
139
140// Max value
141constexpr float3 max(const float3 &inA, const float3 &inB) { return float3(max(inA.x, inB.x), max(inA.y, inB.y), max(inA.z, inB.z)); }
142
143// Length
144inline float length(const float3 &inV) { return sqrt(dot(inV, inV)); }
145
146// Normalization
147inline float3 normalize(const float3 &inV) { return inV / length(inV); }
148
149// Rounding to int
150inline float3 round(const float3 &inV) { return float3(round(inV.x), round(inV.y), round(inV.z)); }
151
152// Cross product
153constexpr float3 cross(const float3 &inA, const float3 &inB) { return float3(inA.y * inB.z - inA.z * inB.y, inA.z * inB.x - inA.x * inB.z, inA.x * inB.y - inA.y * inB.x); }
154
156// float4
158
159struct int4;
160
161struct float4
162{
163 // Constructors
164 inline float4() = default;
165 constexpr float4(const float3 &inV, float inW) : x(inV.x), y(inV.y), z(inV.z), w(inW) { }
166 constexpr float4(float inX, float inY, float inZ, float inW) : x(inX), y(inY), z(inZ), w(inW) { }
167 explicit constexpr float4(float inS) : x(inS), y(inS), z(inS), w(inS) { }
168 explicit constexpr float4(const int4 &inV);
169
170 // Operators
171 constexpr float4 & operator += (const float4 &inRHS) { x += inRHS.x; y += inRHS.y; z += inRHS.z; w += inRHS.w; return *this; }
172 constexpr float4 & operator -= (const float4 &inRHS) { x -= inRHS.x; y -= inRHS.y; z -= inRHS.z; w -= inRHS.w; return *this; }
173 constexpr float4 & operator *= (float inRHS) { x *= inRHS; y *= inRHS; z *= inRHS; w *= inRHS; return *this; }
174 constexpr float4 & operator /= (float inRHS) { x /= inRHS; y /= inRHS; z /= inRHS; w /= inRHS; return *this; }
175 constexpr float4 & operator *= (const float4 &inRHS) { x *= inRHS.x; y *= inRHS.y; z *= inRHS.z; w *= inRHS.w; return *this; }
176 constexpr float4 & operator /= (const float4 &inRHS) { x /= inRHS.x; y /= inRHS.y; z /= inRHS.z; w /= inRHS.w; return *this; }
177
178 // Equality
179 constexpr bool operator == (const float4 &inRHS) const { return x == inRHS.x && y == inRHS.y && z == inRHS.z && w == inRHS.w; }
180 constexpr bool operator != (const float4 &inRHS) const { return !(*this == inRHS); }
181
182 // Component access
183 const float & operator [] (uint inIndex) const { return (&x)[inIndex]; }
184 float & operator [] (uint inIndex) { return (&x)[inIndex]; }
185
186 // Swizzling (note return value is const to prevent assignment to swizzled results)
187 const float2 swizzle_xy() const { return float2(x, y); }
188 const float2 swizzle_yx() const { return float2(y, x); }
189 const float3 swizzle_xyz() const { return float3(x, y, z); }
190 const float3 swizzle_xzy() const { return float3(x, z, y); }
191 const float3 swizzle_yxz() const { return float3(y, x, z); }
192 const float3 swizzle_yzx() const { return float3(y, z, x); }
193 const float3 swizzle_zxy() const { return float3(z, x, y); }
194 const float3 swizzle_zyx() const { return float3(z, y, x); }
195 const float4 swizzle_xywz() const { return float4(x, y, w, z); }
196 const float4 swizzle_xwyz() const { return float4(x, w, y, z); }
197 const float4 swizzle_wxyz() const { return float4(w, x, y, z); }
198
199 float x, y, z, w;
200};
201
202// Operators
203constexpr float4 operator - (const float4 &inA) { return float4(-inA.x, -inA.y, -inA.z, -inA.w); }
204constexpr float4 operator + (const float4 &inA, const float4 &inB) { return float4(inA.x + inB.x, inA.y + inB.y, inA.z + inB.z, inA.w + inB.w); }
205constexpr float4 operator - (const float4 &inA, const float4 &inB) { return float4(inA.x - inB.x, inA.y - inB.y, inA.z - inB.z, inA.w - inB.w); }
206constexpr float4 operator * (const float4 &inA, const float4 &inB) { return float4(inA.x * inB.x, inA.y * inB.y, inA.z * inB.z, inA.w * inB.w); }
207constexpr float4 operator / (const float4 &inA, const float4 &inB) { return float4(inA.x / inB.x, inA.y / inB.y, inA.z / inB.z, inA.w / inB.w); }
208constexpr float4 operator * (const float4 &inA, float inS) { return float4(inA.x * inS, inA.y * inS, inA.z * inS, inA.w * inS); }
209constexpr float4 operator * (float inS, const float4 &inA) { return inA * inS; }
210constexpr float4 operator / (const float4 &inA, float inS) { return float4(inA.x / inS, inA.y / inS, inA.z / inS, inA.w / inS); }
211
212// Dot product
213constexpr float dot(const float4 &inA, const float4 &inB) { return inA.x * inB.x + inA.y * inB.y + inA.z * inB.z + inA.w * inB.w; }
214
215// Min value
216constexpr float4 min(const float4 &inA, const float4 &inB) { return float4(min(inA.x, inB.x), min(inA.y, inB.y), min(inA.z, inB.z), min(inA.w, inB.w)); }
217
218// Max value
219constexpr float4 max(const float4 &inA, const float4 &inB) { return float4(max(inA.x, inB.x), max(inA.y, inB.y), max(inA.z, inB.z), max(inA.w, inB.w)); }
220
221// Length
222inline float length(const float4 &inV) { return sqrt(dot(inV, inV)); }
223
224// Normalization
225inline float4 normalize(const float4 &inV) { return inV / length(inV); }
226
227// Rounding to int
228inline float4 round(const float4 &inV) { return float4(round(inV.x), round(inV.y), round(inV.z), round(inV.w)); }
229
231// uint3
233
234struct uint3
235{
236 inline uint3() = default;
237 constexpr uint3(uint32 inX, uint32 inY, uint32 inZ) : x(inX), y(inY), z(inZ) { }
238 explicit constexpr uint3(const float3 &inV) : x(uint32(inV.x)), y(uint32(inV.y)), z(uint32(inV.z)) { }
239
240 // Operators
241 constexpr uint3 & operator += (const uint3 &inRHS) { x += inRHS.x; y += inRHS.y; z += inRHS.z; return *this; }
242 constexpr uint3 & operator -= (const uint3 &inRHS) { x -= inRHS.x; y -= inRHS.y; z -= inRHS.z; return *this; }
243 constexpr uint3 & operator *= (uint32 inRHS) { x *= inRHS; y *= inRHS; z *= inRHS; return *this; }
244 constexpr uint3 & operator /= (uint32 inRHS) { x /= inRHS; y /= inRHS; z /= inRHS; return *this; }
245 constexpr uint3 & operator *= (const uint3 &inRHS) { x *= inRHS.x; y *= inRHS.y; z *= inRHS.z; return *this; }
246 constexpr uint3 & operator /= (const uint3 &inRHS) { x /= inRHS.x; y /= inRHS.y; z /= inRHS.z; return *this; }
247
248 // Equality
249 constexpr bool operator == (const uint3 &inRHS) const { return x == inRHS.x && y == inRHS.y && z == inRHS.z; }
250 constexpr bool operator != (const uint3 &inRHS) const { return !(*this == inRHS); }
251
252 // Component access
253 const uint32 & operator [] (uint inIndex) const { return (&x)[inIndex]; }
254 uint32 & operator [] (uint inIndex) { return (&x)[inIndex]; }
255
256 // Swizzling (note return value is const to prevent assignment to swizzled results)
257 const uint3 swizzle_xyz() const { return uint3(x, y, z); }
258 const uint3 swizzle_xzy() const { return uint3(x, z, y); }
259 const uint3 swizzle_yxz() const { return uint3(y, x, z); }
260 const uint3 swizzle_yzx() const { return uint3(y, z, x); }
261 const uint3 swizzle_zxy() const { return uint3(z, x, y); }
262 const uint3 swizzle_zyx() const { return uint3(z, y, x); }
263
264 uint32 x, y, z;
265};
266
267// Operators
268constexpr uint3 operator + (const uint3 &inA, const uint3 &inB) { return uint3(inA.x + inB.x, inA.y + inB.y, inA.z + inB.z); }
269constexpr uint3 operator - (const uint3 &inA, const uint3 &inB) { return uint3(inA.x - inB.x, inA.y - inB.y, inA.z - inB.z); }
270constexpr uint3 operator * (const uint3 &inA, const uint3 &inB) { return uint3(inA.x * inB.x, inA.y * inB.y, inA.z * inB.z); }
271constexpr uint3 operator / (const uint3 &inA, const uint3 &inB) { return uint3(inA.x / inB.x, inA.y / inB.y, inA.z / inB.z); }
272constexpr uint3 operator * (const uint3 &inA, uint32 inS) { return uint3(inA.x * inS, inA.y * inS, inA.z * inS); }
273constexpr uint3 operator * (uint32 inS, const uint3 &inA) { return inA * inS; }
274constexpr uint3 operator / (const uint3 &inA, uint32 inS) { return uint3(inA.x / inS, inA.y / inS, inA.z / inS); }
275
276// Dot product
277constexpr uint32 dot(const uint3 &inA, const uint3 &inB) { return inA.x * inB.x + inA.y * inB.y + inA.z * inB.z; }
278
279// Min value
280constexpr uint3 min(const uint3 &inA, const uint3 &inB) { return uint3(min(inA.x, inB.x), min(inA.y, inB.y), min(inA.z, inB.z)); }
281
282// Max value
283constexpr uint3 max(const uint3 &inA, const uint3 &inB) { return uint3(max(inA.x, inB.x), max(inA.y, inB.y), max(inA.z, inB.z)); }
284
286// uint4
288
289struct uint4
290{
291 // Constructors
292 inline uint4() = default;
293 constexpr uint4(const uint3 &inV, uint32 inW) : x(inV.x), y(inV.y), z(inV.z), w(inW) { }
294 constexpr uint4(uint32 inX, uint32 inY, uint32 inZ, uint32 inW) : x(inX), y(inY), z(inZ), w(inW) { }
295 explicit constexpr uint4(uint32 inS) : x(inS), y(inS), z(inS), w(inS) { }
296
297 // Operators
298 constexpr uint4 & operator += (const uint4 &inRHS) { x += inRHS.x; y += inRHS.y; z += inRHS.z; w += inRHS.w; return *this; }
299 constexpr uint4 & operator -= (const uint4 &inRHS) { x -= inRHS.x; y -= inRHS.y; z -= inRHS.z; w -= inRHS.w; return *this; }
300 constexpr uint4 & operator *= (uint32 inRHS) { x *= inRHS; y *= inRHS; z *= inRHS; w *= inRHS; return *this; }
301 constexpr uint4 & operator /= (uint32 inRHS) { x /= inRHS; y /= inRHS; z /= inRHS; w /= inRHS; return *this; }
302 constexpr uint4 & operator *= (const uint4 &inRHS) { x *= inRHS.x; y *= inRHS.y; z *= inRHS.z; w *= inRHS.w; return *this; }
303 constexpr uint4 & operator /= (const uint4 &inRHS) { x /= inRHS.x; y /= inRHS.y; z /= inRHS.z; w /= inRHS.w; return *this; }
304
305 // Equality
306 constexpr bool operator == (const uint4 &inRHS) const { return x == inRHS.x && y == inRHS.y && z == inRHS.z && w == inRHS.w; }
307 constexpr bool operator != (const uint4 &inRHS) const { return !(*this == inRHS); }
308
309 // Component access
310 const uint32 & operator [] (uint inIndex) const { return (&x)[inIndex]; }
311 uint32 & operator [] (uint inIndex) { return (&x)[inIndex]; }
312
313 // Swizzling (note return value is const to prevent assignment to swizzled results)
314 const uint3 swizzle_xyz() const { return uint3(x, y, z); }
315 const uint3 swizzle_xzy() const { return uint3(x, z, y); }
316 const uint3 swizzle_yxz() const { return uint3(y, x, z); }
317 const uint3 swizzle_yzx() const { return uint3(y, z, x); }
318 const uint3 swizzle_zxy() const { return uint3(z, x, y); }
319 const uint3 swizzle_zyx() const { return uint3(z, y, x); }
320 const uint4 swizzle_xywz() const { return uint4(x, y, w, z); }
321 const uint4 swizzle_xwyz() const { return uint4(x, w, y, z); }
322 const uint4 swizzle_wxyz() const { return uint4(w, x, y, z); }
323
324 uint32 x, y, z, w;
325};
326
327// Operators
328constexpr uint4 operator + (const uint4 &inA, const uint4 &inB) { return uint4(inA.x + inB.x, inA.y + inB.y, inA.z + inB.z, inA.w + inB.w); }
329constexpr uint4 operator - (const uint4 &inA, const uint4 &inB) { return uint4(inA.x - inB.x, inA.y - inB.y, inA.z - inB.z, inA.w - inB.w); }
330constexpr uint4 operator * (const uint4 &inA, const uint4 &inB) { return uint4(inA.x * inB.x, inA.y * inB.y, inA.z * inB.z, inA.w * inB.w); }
331constexpr uint4 operator / (const uint4 &inA, const uint4 &inB) { return uint4(inA.x / inB.x, inA.y / inB.y, inA.z / inB.z, inA.w / inB.w); }
332constexpr uint4 operator * (const uint4 &inA, uint32 inS) { return uint4(inA.x * inS, inA.y * inS, inA.z * inS, inA.w * inS); }
333constexpr uint4 operator * (uint32 inS, const uint4 &inA) { return inA * inS; }
334constexpr uint4 operator / (const uint4 &inA, uint32 inS) { return uint4(inA.x / inS, inA.y / inS, inA.z / inS, inA.w / inS); }
335
336// Dot product
337constexpr uint32 dot(const uint4 &inA, const uint4 &inB) { return inA.x * inB.x + inA.y * inB.y + inA.z * inB.z + inA.w * inB.w; }
338
339// Min value
340constexpr uint4 min(const uint4 &inA, const uint4 &inB) { return uint4(min(inA.x, inB.x), min(inA.y, inB.y), min(inA.z, inB.z), min(inA.w, inB.w)); }
341
342// Max value
343constexpr uint4 max(const uint4 &inA, const uint4 &inB) { return uint4(max(inA.x, inB.x), max(inA.y, inB.y), max(inA.z, inB.z), max(inA.w, inB.w)); }
344
346// int3
348
349struct int3
350{
351 inline int3() = default;
352 constexpr int3(int inX, int inY, int inZ) : x(inX), y(inY), z(inZ) { }
353 explicit constexpr int3(const float3 &inV) : x(int(inV.x)), y(int(inV.y)), z(int(inV.z)) { }
354
355 // Operators
356 constexpr int3 & operator += (const int3 &inRHS) { x += inRHS.x; y += inRHS.y; z += inRHS.z; return *this; }
357 constexpr int3 & operator -= (const int3 &inRHS) { x -= inRHS.x; y -= inRHS.y; z -= inRHS.z; return *this; }
358 constexpr int3 & operator *= (int inRHS) { x *= inRHS; y *= inRHS; z *= inRHS; return *this; }
359 constexpr int3 & operator /= (int inRHS) { x /= inRHS; y /= inRHS; z /= inRHS; return *this; }
360 constexpr int3 & operator *= (const int3 &inRHS) { x *= inRHS.x; y *= inRHS.y; z *= inRHS.z; return *this; }
361 constexpr int3 & operator /= (const int3 &inRHS) { x /= inRHS.x; y /= inRHS.y; z /= inRHS.z; return *this; }
362
363 // Equality
364 constexpr bool operator == (const int3 &inRHS) const { return x == inRHS.x && y == inRHS.y && z == inRHS.z; }
365 constexpr bool operator != (const int3 &inRHS) const { return !(*this == inRHS); }
366
367 // Component access
368 const int & operator [] (uint inIndex) const { return (&x)[inIndex]; }
369 int & operator [] (uint inIndex) { return (&x)[inIndex]; }
370
371 // Swizzling (note return value is const to prevent assignment to swizzled results)
372 const int3 swizzle_xyz() const { return int3(x, y, z); }
373 const int3 swizzle_xzy() const { return int3(x, z, y); }
374 const int3 swizzle_yxz() const { return int3(y, x, z); }
375 const int3 swizzle_yzx() const { return int3(y, z, x); }
376 const int3 swizzle_zxy() const { return int3(z, x, y); }
377 const int3 swizzle_zyx() const { return int3(z, y, x); }
378
379 int x, y, z;
380};
381
382// Operators
383constexpr int3 operator - (const int3 &inA) { return int3(-inA.x, -inA.y, -inA.z); }
384constexpr int3 operator + (const int3 &inA, const int3 &inB) { return int3(inA.x + inB.x, inA.y + inB.y, inA.z + inB.z); }
385constexpr int3 operator - (const int3 &inA, const int3 &inB) { return int3(inA.x - inB.x, inA.y - inB.y, inA.z - inB.z); }
386constexpr int3 operator * (const int3 &inA, const int3 &inB) { return int3(inA.x * inB.x, inA.y * inB.y, inA.z * inB.z); }
387constexpr int3 operator / (const int3 &inA, const int3 &inB) { return int3(inA.x / inB.x, inA.y / inB.y, inA.z / inB.z); }
388constexpr int3 operator * (const int3 &inA, int inS) { return int3(inA.x * inS, inA.y * inS, inA.z * inS); }
389constexpr int3 operator * (int inS, const int3 &inA) { return inA * inS; }
390constexpr int3 operator / (const int3 &inA, int inS) { return int3(inA.x / inS, inA.y / inS, inA.z / inS); }
391
392// Dot product
393constexpr int dot(const int3 &inA, const int3 &inB) { return inA.x * inB.x + inA.y * inB.y + inA.z * inB.z; }
394
395// Min value
396constexpr int3 min(const int3 &inA, const int3 &inB) { return int3(min(inA.x, inB.x), min(inA.y, inB.y), min(inA.z, inB.z)); }
397
398// Max value
399constexpr int3 max(const int3 &inA, const int3 &inB) { return int3(max(inA.x, inB.x), max(inA.y, inB.y), max(inA.z, inB.z)); }
400
402// int4
404
405struct int4
406{
407 // Constructors
408 inline int4() = default;
409 constexpr int4(const int3 &inV, int inW) : x(inV.x), y(inV.y), z(inV.z), w(inW) { }
410 constexpr int4(int inX, int inY, int inZ, int inW) : x(inX), y(inY), z(inZ), w(inW) { }
411 explicit constexpr int4(int inS) : x(inS), y(inS), z(inS), w(inS) { }
412 explicit constexpr int4(const float4 &inV) : x(int(inV.x)), y(int(inV.y)), z(int(inV.z)), w(int(inV.w)) { }
413
414 // Operators
415 constexpr int4 & operator += (const int4 &inRHS) { x += inRHS.x; y += inRHS.y; z += inRHS.z; w += inRHS.w; return *this; }
416 constexpr int4 & operator -= (const int4 &inRHS) { x -= inRHS.x; y -= inRHS.y; z -= inRHS.z; w -= inRHS.w; return *this; }
417 constexpr int4 & operator *= (int inRHS) { x *= inRHS; y *= inRHS; z *= inRHS; w *= inRHS; return *this; }
418 constexpr int4 & operator /= (int inRHS) { x /= inRHS; y /= inRHS; z /= inRHS; w /= inRHS; return *this; }
419 constexpr int4 & operator *= (const int4 &inRHS) { x *= inRHS.x; y *= inRHS.y; z *= inRHS.z; w *= inRHS.w; return *this; }
420 constexpr int4 & operator /= (const int4 &inRHS) { x /= inRHS.x; y /= inRHS.y; z /= inRHS.z; w /= inRHS.w; return *this; }
421
422 // Equality
423 constexpr bool operator == (const int4 &inRHS) const { return x == inRHS.x && y == inRHS.y && z == inRHS.z && w == inRHS.w; }
424 constexpr bool operator != (const int4 &inRHS) const { return !(*this == inRHS); }
425
426 // Component access
427 const int & operator [] (uint inIndex) const { return (&x)[inIndex]; }
428 int & operator [] (uint inIndex) { return (&x)[inIndex]; }
429
430 // Swizzling (note return value is const to prevent assignment to swizzled results)
431 const int3 swizzle_xyz() const { return int3(x, y, z); }
432 const int3 swizzle_xzy() const { return int3(x, z, y); }
433 const int3 swizzle_yxz() const { return int3(y, x, z); }
434 const int3 swizzle_yzx() const { return int3(y, z, x); }
435 const int3 swizzle_zxy() const { return int3(z, x, y); }
436 const int3 swizzle_zyx() const { return int3(z, y, x); }
437 const int4 swizzle_xywz() const { return int4(x, y, w, z); }
438 const int4 swizzle_xwyz() const { return int4(x, w, y, z); }
439 const int4 swizzle_wxyz() const { return int4(w, x, y, z); }
440
441 int x, y, z, w;
442};
443
444// Operators
445constexpr int4 operator - (const int4 &inA) { return int4(-inA.x, -inA.y, -inA.z, -inA.w); }
446constexpr int4 operator + (const int4 &inA, const int4 &inB) { return int4(inA.x + inB.x, inA.y + inB.y, inA.z + inB.z, inA.w + inB.w); }
447constexpr int4 operator - (const int4 &inA, const int4 &inB) { return int4(inA.x - inB.x, inA.y - inB.y, inA.z - inB.z, inA.w - inB.w); }
448constexpr int4 operator * (const int4 &inA, const int4 &inB) { return int4(inA.x * inB.x, inA.y * inB.y, inA.z * inB.z, inA.w * inB.w); }
449constexpr int4 operator / (const int4 &inA, const int4 &inB) { return int4(inA.x / inB.x, inA.y / inB.y, inA.z / inB.z, inA.w / inB.w); }
450constexpr int4 operator * (const int4 &inA, int inS) { return int4(inA.x * inS, inA.y * inS, inA.z * inS, inA.w * inS); }
451constexpr int4 operator * (int inS, const int4 &inA) { return inA * inS; }
452constexpr int4 operator / (const int4 &inA, int inS) { return int4(inA.x / inS, inA.y / inS, inA.z / inS, inA.w / inS); }
453
454// Dot product
455constexpr int dot(const int4 &inA, const int4 &inB) { return inA.x * inB.x + inA.y * inB.y + inA.z * inB.z + inA.w * inB.w; }
456
457// Min value
458constexpr int4 min(const int4 &inA, const int4 &inB) { return int4(min(inA.x, inB.x), min(inA.y, inB.y), min(inA.z, inB.z), min(inA.w, inB.w)); }
459
460// Max value
461constexpr int4 max(const int4 &inA, const int4 &inB) { return int4(max(inA.x, inB.x), max(inA.y, inB.y), max(inA.z, inB.z), max(inA.w, inB.w)); }
462
464// Mat44
466
467struct Mat44
468{
469 // Constructors
470 inline Mat44() = default;
471 constexpr Mat44(const float4 &inC0, const float4 &inC1, const float4 &inC2, const float4 &inC3) : c { inC0, inC1, inC2, inC3 } { }
472
473 // Columns
474 float4 & operator [] (uint inIndex) { return c[inIndex]; }
475 const float4 & operator [] (uint inIndex) const { return c[inIndex]; }
476
477private:
478 float4 c[4];
479};
480
482// Other types
484
485using Quat = float4;
486using Plane = float4;
487
488// Clamp value
489template <class T>
490constexpr T clamp(const T &inValue, const T &inMinValue, const T &inMaxValue)
491{
492 return min(max(inValue, inMinValue), inMaxValue);
493}
494
495// Atomic add
496template <class T>
497T JPH_AtomicAdd(T &ioT, const T &inValue)
498{
499 std::atomic<T> *value = reinterpret_cast<std::atomic<T> *>(&ioT);
500 return value->fetch_add(inValue) + inValue;
501}
502
503// Bitcast float4 to int4
504inline int4 asint(const float4 &inV) { return int4(BitCast<int>(inV.x), BitCast<int>(inV.y), BitCast<int>(inV.z), BitCast<int>(inV.w)); }
505
506// Functions that couldn't be declared earlier
507constexpr float3::float3(const uint3 &inV) : x(float(inV.x)), y(float(inV.y)), z(float(inV.z)) { }
508constexpr float4::float4(const int4 &inV) : x(float(inV.x)), y(float(inV.y)), z(float(inV.z)), w(float(inV.w)) { }
509
510// Swizzle operators
511#define xy swizzle_xy()
512#define yx swizzle_yx()
513#define xyz swizzle_xyz()
514#define xzy swizzle_xzy()
515#define yxz swizzle_yxz()
516#define yzx swizzle_yzx()
517#define zxy swizzle_zxy()
518#define zyx swizzle_zyx()
519#define xywz swizzle_xywz()
520#define xwyz swizzle_xwyz()
521#define wxyz swizzle_wxyz()
522
523} // HLSLToCPP
524
525JPH_NAMESPACE_END
uint
unsigned int uint
Definition Core.h:500
JPH_NAMESPACE_END
#define JPH_NAMESPACE_END
Definition Core.h:425
uint32
std::uint32_t uint32
Definition Core.h:503
JPH_NAMESPACE_BEGIN
#define JPH_NAMESPACE_BEGIN
Definition Core.h:419
BitCast
JPH_INLINE To BitCast(const From &inValue)
Definition Math.h:192
JPH_AtomicAdd
#define JPH_AtomicAdd
Definition ShaderCore.h:74
HLSLToCPP
Definition HLSLToCPP.h:11
HLSLToCPP::asint
int4 asint(const float4 &inV)
Definition HLSLToCPP.h:504
HLSLToCPP::round
float2 round(const float2 &inV)
Definition HLSLToCPP.h:78
HLSLToCPP::operator/
constexpr float2 operator/(const float2 &inA, const float2 &inB)
Definition HLSLToCPP.h:57
HLSLToCPP::cross
constexpr float3 cross(const float3 &inA, const float3 &inB)
Definition HLSLToCPP.h:153
HLSLToCPP::clamp
constexpr T clamp(const T &inValue, const T &inMinValue, const T &inMaxValue)
Definition HLSLToCPP.h:490
HLSLToCPP::operator+
constexpr float2 operator+(const float2 &inA, const float2 &inB)
Definition HLSLToCPP.h:54
HLSLToCPP::operator*
constexpr float2 operator*(const float2 &inA, const float2 &inB)
Definition HLSLToCPP.h:56
HLSLToCPP::min
constexpr float2 min(const float2 &inA, const float2 &inB)
Definition HLSLToCPP.h:66
HLSLToCPP::max
constexpr float2 max(const float2 &inA, const float2 &inB)
Definition HLSLToCPP.h:69
HLSLToCPP::length
float length(const float2 &inV)
Definition HLSLToCPP.h:72
HLSLToCPP::operator-
constexpr float2 operator-(const float2 &inA)
Definition HLSLToCPP.h:53
HLSLToCPP::dot
constexpr float dot(const float2 &inA, const float2 &inB)
Definition HLSLToCPP.h:63
HLSLToCPP::normalize
float2 normalize(const float2 &inV)
Definition HLSLToCPP.h:75
HLSLToCPP::Mat44
Definition HLSLToCPP.h:468
HLSLToCPP::Mat44::operator[]
float4 & operator[](uint inIndex)
Definition HLSLToCPP.h:474
HLSLToCPP::Mat44::Mat44
constexpr Mat44(const float4 &inC0, const float4 &inC1, const float4 &inC2, const float4 &inC3)
Definition HLSLToCPP.h:471
HLSLToCPP::float2
Definition HLSLToCPP.h:23
HLSLToCPP::float2::x
float x
Definition HLSLToCPP.h:49
HLSLToCPP::float2::operator+=
constexpr float2 & operator+=(const float2 &inRHS)
Definition HLSLToCPP.h:30
HLSLToCPP::float2::swizzle_xy
const float2 swizzle_xy() const
Definition HLSLToCPP.h:46
HLSLToCPP::float2::operator!=
constexpr bool operator!=(const float2 &inRHS) const
Definition HLSLToCPP.h:39
HLSLToCPP::float2::y
float y
Definition HLSLToCPP.h:49
HLSLToCPP::float2::swizzle_yx
const float2 swizzle_yx() const
Definition HLSLToCPP.h:47
HLSLToCPP::float2::operator==
constexpr bool operator==(const float2 &inRHS) const
Definition HLSLToCPP.h:38
HLSLToCPP::float2::operator/=
constexpr float2 & operator/=(float inRHS)
Definition HLSLToCPP.h:33
HLSLToCPP::float2::operator[]
const float & operator[](uint inIndex) const
Definition HLSLToCPP.h:42
HLSLToCPP::float2::operator-=
constexpr float2 & operator-=(const float2 &inRHS)
Definition HLSLToCPP.h:31
HLSLToCPP::float2::float2
constexpr float2(float inS)
Definition HLSLToCPP.h:27
HLSLToCPP::float2::operator*=
constexpr float2 & operator*=(float inRHS)
Definition HLSLToCPP.h:32
HLSLToCPP::float2::float2
constexpr float2(float inX, float inY)
Definition HLSLToCPP.h:26
HLSLToCPP::float3
Definition HLSLToCPP.h:87
HLSLToCPP::float3::swizzle_xy
const float2 swizzle_xy() const
Definition HLSLToCPP.h:112
HLSLToCPP::float3::z
float z
Definition HLSLToCPP.h:121
HLSLToCPP::float3::operator*=
constexpr float3 & operator*=(float inRHS)
Definition HLSLToCPP.h:98
HLSLToCPP::float3::float3
constexpr float3(float inX, float inY, float inZ)
Definition HLSLToCPP.h:91
HLSLToCPP::float3::operator==
constexpr bool operator==(const float3 &inRHS) const
Definition HLSLToCPP.h:104
HLSLToCPP::float3::operator!=
constexpr bool operator!=(const float3 &inRHS) const
Definition HLSLToCPP.h:105
HLSLToCPP::float3::operator/=
constexpr float3 & operator/=(float inRHS)
Definition HLSLToCPP.h:99
HLSLToCPP::float3::swizzle_zxy
const float3 swizzle_zxy() const
Definition HLSLToCPP.h:118
HLSLToCPP::float3::swizzle_yx
const float2 swizzle_yx() const
Definition HLSLToCPP.h:113
HLSLToCPP::float3::swizzle_yzx
const float3 swizzle_yzx() const
Definition HLSLToCPP.h:117
HLSLToCPP::float3::swizzle_xzy
const float3 swizzle_xzy() const
Definition HLSLToCPP.h:115
HLSLToCPP::float3::x
float x
Definition HLSLToCPP.h:121
HLSLToCPP::float3::operator[]
const float & operator[](uint inIndex) const
Definition HLSLToCPP.h:108
HLSLToCPP::float3::swizzle_zyx
const float3 swizzle_zyx() const
Definition HLSLToCPP.h:119
HLSLToCPP::float3::swizzle_xyz
const float3 swizzle_xyz() const
Definition HLSLToCPP.h:114
HLSLToCPP::float3::float3
constexpr float3(const float2 &inV, float inZ)
Definition HLSLToCPP.h:90
HLSLToCPP::float3::operator-=
constexpr float3 & operator-=(const float3 &inRHS)
Definition HLSLToCPP.h:97
HLSLToCPP::float3::float3
constexpr float3(float inS)
Definition HLSLToCPP.h:92
HLSLToCPP::float3::swizzle_yxz
const float3 swizzle_yxz() const
Definition HLSLToCPP.h:116
HLSLToCPP::float3::operator+=
constexpr float3 & operator+=(const float3 &inRHS)
Definition HLSLToCPP.h:96
HLSLToCPP::float3::y
float y
Definition HLSLToCPP.h:121
HLSLToCPP::float4
Definition HLSLToCPP.h:162
HLSLToCPP::float4::float4
constexpr float4(float inX, float inY, float inZ, float inW)
Definition HLSLToCPP.h:166
HLSLToCPP::float4::swizzle_xzy
const float3 swizzle_xzy() const
Definition HLSLToCPP.h:190
HLSLToCPP::float4::swizzle_yxz
const float3 swizzle_yxz() const
Definition HLSLToCPP.h:191
HLSLToCPP::float4::operator/=
constexpr float4 & operator/=(float inRHS)
Definition HLSLToCPP.h:174
HLSLToCPP::float4::operator[]
const float & operator[](uint inIndex) const
Definition HLSLToCPP.h:183
HLSLToCPP::float4::z
float z
Definition HLSLToCPP.h:199
HLSLToCPP::float4::float4
constexpr float4(float inS)
Definition HLSLToCPP.h:167
HLSLToCPP::float4::operator==
constexpr bool operator==(const float4 &inRHS) const
Definition HLSLToCPP.h:179
HLSLToCPP::float4::swizzle_wxyz
const float4 swizzle_wxyz() const
Definition HLSLToCPP.h:197
HLSLToCPP::float4::swizzle_zyx
const float3 swizzle_zyx() const
Definition HLSLToCPP.h:194
HLSLToCPP::float4::swizzle_xwyz
const float4 swizzle_xwyz() const
Definition HLSLToCPP.h:196
HLSLToCPP::float4::y
float y
Definition HLSLToCPP.h:199
HLSLToCPP::float4::swizzle_yzx
const float3 swizzle_yzx() const
Definition HLSLToCPP.h:192
HLSLToCPP::float4::operator-=
constexpr float4 & operator-=(const float4 &inRHS)
Definition HLSLToCPP.h:172
HLSLToCPP::float4::swizzle_xywz
const float4 swizzle_xywz() const
Definition HLSLToCPP.h:195
HLSLToCPP::float4::x
float x
Definition HLSLToCPP.h:199
HLSLToCPP::float4::swizzle_xyz
const float3 swizzle_xyz() const
Definition HLSLToCPP.h:189
HLSLToCPP::float4::operator+=
constexpr float4 & operator+=(const float4 &inRHS)
Definition HLSLToCPP.h:171
HLSLToCPP::float4::swizzle_yx
const float2 swizzle_yx() const
Definition HLSLToCPP.h:188
HLSLToCPP::float4::swizzle_xy
const float2 swizzle_xy() const
Definition HLSLToCPP.h:187
HLSLToCPP::float4::w
float w
Definition HLSLToCPP.h:199
HLSLToCPP::float4::operator*=
constexpr float4 & operator*=(float inRHS)
Definition HLSLToCPP.h:173
HLSLToCPP::float4::float4
constexpr float4(const float3 &inV, float inW)
Definition HLSLToCPP.h:165
HLSLToCPP::float4::operator!=
constexpr bool operator!=(const float4 &inRHS) const
Definition HLSLToCPP.h:180
HLSLToCPP::float4::swizzle_zxy
const float3 swizzle_zxy() const
Definition HLSLToCPP.h:193
HLSLToCPP::int3
Definition HLSLToCPP.h:350
HLSLToCPP::int3::operator+=
constexpr int3 & operator+=(const int3 &inRHS)
Definition HLSLToCPP.h:356
HLSLToCPP::int3::y
int y
Definition HLSLToCPP.h:379
HLSLToCPP::int3::operator[]
const int & operator[](uint inIndex) const
Definition HLSLToCPP.h:368
HLSLToCPP::int3::operator!=
constexpr bool operator!=(const int3 &inRHS) const
Definition HLSLToCPP.h:365
HLSLToCPP::int3::swizzle_yxz
const int3 swizzle_yxz() const
Definition HLSLToCPP.h:374
HLSLToCPP::int3::x
int x
Definition HLSLToCPP.h:379
HLSLToCPP::int3::swizzle_yzx
const int3 swizzle_yzx() const
Definition HLSLToCPP.h:375
HLSLToCPP::int3::swizzle_zyx
const int3 swizzle_zyx() const
Definition HLSLToCPP.h:377
HLSLToCPP::int3::int3
int3()=default
HLSLToCPP::int3::operator*=
constexpr int3 & operator*=(int inRHS)
Definition HLSLToCPP.h:358
HLSLToCPP::int3::z
int z
Definition HLSLToCPP.h:379
HLSLToCPP::int3::operator-=
constexpr int3 & operator-=(const int3 &inRHS)
Definition HLSLToCPP.h:357
HLSLToCPP::int3::int3
constexpr int3(const float3 &inV)
Definition HLSLToCPP.h:353
HLSLToCPP::int3::int3
constexpr int3(int inX, int inY, int inZ)
Definition HLSLToCPP.h:352
HLSLToCPP::int3::operator/=
constexpr int3 & operator/=(int inRHS)
Definition HLSLToCPP.h:359
HLSLToCPP::int3::operator==
constexpr bool operator==(const int3 &inRHS) const
Definition HLSLToCPP.h:364
HLSLToCPP::int3::swizzle_xzy
const int3 swizzle_xzy() const
Definition HLSLToCPP.h:373
HLSLToCPP::int3::swizzle_xyz
const int3 swizzle_xyz() const
Definition HLSLToCPP.h:372
HLSLToCPP::int3::swizzle_zxy
const int3 swizzle_zxy() const
Definition HLSLToCPP.h:376
HLSLToCPP::int4
Definition HLSLToCPP.h:406
HLSLToCPP::int4::swizzle_yxz
const int3 swizzle_yxz() const
Definition HLSLToCPP.h:433
HLSLToCPP::int4::operator==
constexpr bool operator==(const int4 &inRHS) const
Definition HLSLToCPP.h:423
HLSLToCPP::int4::w
int w
Definition HLSLToCPP.h:441
HLSLToCPP::int4::y
int y
Definition HLSLToCPP.h:441
HLSLToCPP::int4::swizzle_zxy
const int3 swizzle_zxy() const
Definition HLSLToCPP.h:435
HLSLToCPP::int4::swizzle_xwyz
const int4 swizzle_xwyz() const
Definition HLSLToCPP.h:438
HLSLToCPP::int4::swizzle_xzy
const int3 swizzle_xzy() const
Definition HLSLToCPP.h:432
HLSLToCPP::int4::operator/=
constexpr int4 & operator/=(int inRHS)
Definition HLSLToCPP.h:418
HLSLToCPP::int4::int4
constexpr int4(int inS)
Definition HLSLToCPP.h:411
HLSLToCPP::int4::operator-=
constexpr int4 & operator-=(const int4 &inRHS)
Definition HLSLToCPP.h:416
HLSLToCPP::int4::int4
int4()=default
HLSLToCPP::int4::swizzle_yzx
const int3 swizzle_yzx() const
Definition HLSLToCPP.h:434
HLSLToCPP::int4::swizzle_zyx
const int3 swizzle_zyx() const
Definition HLSLToCPP.h:436
HLSLToCPP::int4::int4
constexpr int4(const int3 &inV, int inW)
Definition HLSLToCPP.h:409
HLSLToCPP::int4::operator*=
constexpr int4 & operator*=(int inRHS)
Definition HLSLToCPP.h:417
HLSLToCPP::int4::x
int x
Definition HLSLToCPP.h:441
HLSLToCPP::int4::int4
constexpr int4(int inX, int inY, int inZ, int inW)
Definition HLSLToCPP.h:410
HLSLToCPP::int4::z
int z
Definition HLSLToCPP.h:441
HLSLToCPP::int4::operator+=
constexpr int4 & operator+=(const int4 &inRHS)
Definition HLSLToCPP.h:415
HLSLToCPP::int4::swizzle_wxyz
const int4 swizzle_wxyz() const
Definition HLSLToCPP.h:439
HLSLToCPP::int4::operator[]
const int & operator[](uint inIndex) const
Definition HLSLToCPP.h:427
HLSLToCPP::int4::operator!=
constexpr bool operator!=(const int4 &inRHS) const
Definition HLSLToCPP.h:424
HLSLToCPP::int4::int4
constexpr int4(const float4 &inV)
Definition HLSLToCPP.h:412
HLSLToCPP::int4::swizzle_xywz
const int4 swizzle_xywz() const
Definition HLSLToCPP.h:437
HLSLToCPP::int4::swizzle_xyz
const int3 swizzle_xyz() const
Definition HLSLToCPP.h:431
HLSLToCPP::uint3
Definition HLSLToCPP.h:235
HLSLToCPP::uint3::swizzle_yzx
const uint3 swizzle_yzx() const
Definition HLSLToCPP.h:260
HLSLToCPP::uint3::swizzle_xzy
const uint3 swizzle_xzy() const
Definition HLSLToCPP.h:258
HLSLToCPP::uint3::operator*=
constexpr uint3 & operator*=(uint32 inRHS)
Definition HLSLToCPP.h:243
HLSLToCPP::uint3::swizzle_zxy
const uint3 swizzle_zxy() const
Definition HLSLToCPP.h:261
HLSLToCPP::uint3::swizzle_yxz
const uint3 swizzle_yxz() const
Definition HLSLToCPP.h:259
HLSLToCPP::uint3::operator[]
const uint32 & operator[](uint inIndex) const
Definition HLSLToCPP.h:253
HLSLToCPP::uint3::x
uint32 x
Definition HLSLToCPP.h:264
HLSLToCPP::uint3::operator+=
constexpr uint3 & operator+=(const uint3 &inRHS)
Definition HLSLToCPP.h:241
HLSLToCPP::uint3::operator-=
constexpr uint3 & operator-=(const uint3 &inRHS)
Definition HLSLToCPP.h:242
HLSLToCPP::uint3::swizzle_zyx
const uint3 swizzle_zyx() const
Definition HLSLToCPP.h:262
HLSLToCPP::uint3::y
uint32 y
Definition HLSLToCPP.h:264
HLSLToCPP::uint3::uint3
constexpr uint3(const float3 &inV)
Definition HLSLToCPP.h:238
HLSLToCPP::uint3::operator!=
constexpr bool operator!=(const uint3 &inRHS) const
Definition HLSLToCPP.h:250
HLSLToCPP::uint3::swizzle_xyz
const uint3 swizzle_xyz() const
Definition HLSLToCPP.h:257
HLSLToCPP::uint3::operator/=
constexpr uint3 & operator/=(uint32 inRHS)
Definition HLSLToCPP.h:244
HLSLToCPP::uint3::operator==
constexpr bool operator==(const uint3 &inRHS) const
Definition HLSLToCPP.h:249
HLSLToCPP::uint3::z
uint32 z
Definition HLSLToCPP.h:264
HLSLToCPP::uint3::uint3
constexpr uint3(uint32 inX, uint32 inY, uint32 inZ)
Definition HLSLToCPP.h:237
HLSLToCPP::uint4
Definition HLSLToCPP.h:290
HLSLToCPP::uint4::uint4
constexpr uint4(uint32 inX, uint32 inY, uint32 inZ, uint32 inW)
Definition HLSLToCPP.h:294
HLSLToCPP::uint4::operator!=
constexpr bool operator!=(const uint4 &inRHS) const
Definition HLSLToCPP.h:307
HLSLToCPP::uint4::operator*=
constexpr uint4 & operator*=(uint32 inRHS)
Definition HLSLToCPP.h:300
HLSLToCPP::uint4::swizzle_yzx
const uint3 swizzle_yzx() const
Definition HLSLToCPP.h:317
HLSLToCPP::uint4::operator+=
constexpr uint4 & operator+=(const uint4 &inRHS)
Definition HLSLToCPP.h:298
HLSLToCPP::uint4::uint4
constexpr uint4(const uint3 &inV, uint32 inW)
Definition HLSLToCPP.h:293
HLSLToCPP::uint4::swizzle_zxy
const uint3 swizzle_zxy() const
Definition HLSLToCPP.h:318
HLSLToCPP::uint4::swizzle_zyx
const uint3 swizzle_zyx() const
Definition HLSLToCPP.h:319
HLSLToCPP::uint4::swizzle_yxz
const uint3 swizzle_yxz() const
Definition HLSLToCPP.h:316
HLSLToCPP::uint4::swizzle_xwyz
const uint4 swizzle_xwyz() const
Definition HLSLToCPP.h:321
HLSLToCPP::uint4::operator[]
const uint32 & operator[](uint inIndex) const
Definition HLSLToCPP.h:310
HLSLToCPP::uint4::operator==
constexpr bool operator==(const uint4 &inRHS) const
Definition HLSLToCPP.h:306
HLSLToCPP::uint4::z
uint32 z
Definition HLSLToCPP.h:324
HLSLToCPP::uint4::swizzle_xyz
const uint3 swizzle_xyz() const
Definition HLSLToCPP.h:314
HLSLToCPP::uint4::uint4
constexpr uint4(uint32 inS)
Definition HLSLToCPP.h:295
HLSLToCPP::uint4::x
uint32 x
Definition HLSLToCPP.h:324
HLSLToCPP::uint4::operator-=
constexpr uint4 & operator-=(const uint4 &inRHS)
Definition HLSLToCPP.h:299
HLSLToCPP::uint4::y
uint32 y
Definition HLSLToCPP.h:324
HLSLToCPP::uint4::operator/=
constexpr uint4 & operator/=(uint32 inRHS)
Definition HLSLToCPP.h:301
HLSLToCPP::uint4::swizzle_xzy
const uint3 swizzle_xzy() const
Definition HLSLToCPP.h:315
HLSLToCPP::uint4::w
uint32 w
Definition HLSLToCPP.h:324
HLSLToCPP::uint4::swizzle_xywz
const uint4 swizzle_xywz() const
Definition HLSLToCPP.h:320
HLSLToCPP::uint4::swizzle_wxyz
const uint4 swizzle_wxyz() const
Definition HLSLToCPP.h:322