1 /*========================== begin_copyright_notice ============================
2 
3 Copyright (C) 2019-2021 Intel Corporation
4 
5 SPDX-License-Identifier: MIT
6 
7 ============================= end_copyright_notice ===========================*/
8 
9 #pragma once
10 
11 #include "types.h"
12 #include "Debug.h"
13 
14 namespace iSTD
15 {
16 
17 /*****************************************************************************\
18 STRUCT: iSTD::SVector4
19 \*****************************************************************************/
20 template<class Type>
21 struct SVector4
22 {
23     Type    X;
24     Type    Y;
25     Type    Z;
26     Type    W;
27 
28     Type& operator[] ( const int i )
29     {
30         ASSERT( i >= 0 );
31         ASSERT( i <= 3 );
32         return( ((Type*)this)[i] );
33     }
34 
35     const Type& operator[] ( const int i ) const
36     {
37         ASSERT( i >= 0 );
38         ASSERT( i <= 3 );
39         return( ((Type*)this)[i] );
40     }
41 
42     bool operator == ( const SVector4& vector ) const
43     {
44         return ( ( X == vector.X ) &&
45                  ( Y == vector.Y ) &&
46                  ( Z == vector.Z ) &&
47                  ( W == vector.W ) );
48     }
49 
50     bool operator != ( const SVector4& vector ) const
51     {
52         return ( ( X != vector.X ) ||
53                  ( Y != vector.Y ) ||
54                  ( Z != vector.Z ) ||
55                  ( W != vector.W ) );
56     }
57 };
58 
59 // Specialization of iSTD::SVector4 template for Type float :
60 template<>
61 struct SVector4<float>
62 {
63     float    X;
64     float    Y;
65     float    Z;
66     float    W;
67 
68     float& operator[] ( const int i )
69     {
70         ASSERT( i >= 0 );
71         ASSERT( i <= 3 );
72         return( ((float*)this)[i] );
73     }
74 
75     const float& operator[] ( const int i ) const
76     {
77         ASSERT( i >= 0 );
78         ASSERT( i <= 3 );
79         return( ((float*)this)[i] );
80     }
81 
82     bool operator == ( const SVector4<float>& vector ) const
83     {
84         return ( ( *(DWORD*)&X == *(DWORD*)&vector.X ) &&
85                  ( *(DWORD*)&Y == *(DWORD*)&vector.Y ) &&
86                  ( *(DWORD*)&Z == *(DWORD*)&vector.Z ) &&
87                  ( *(DWORD*)&W == *(DWORD*)&vector.W ) );
88     }
89 
90     bool operator != ( const SVector4<float>& vector ) const
91     {
92         return ( ( *(DWORD*)&X != *(DWORD*)&vector.X ) ||
93                  ( *(DWORD*)&Y != *(DWORD*)&vector.Y ) ||
94                  ( *(DWORD*)&Z != *(DWORD*)&vector.Z ) ||
95                  ( *(DWORD*)&W != *(DWORD*)&vector.W ) );
96     }
97 };
98 
99 /*****************************************************************************\
100 STRUCT: SVector3
101 \*****************************************************************************/
102 template<class Type>
103 struct SVector3
104 {
105     Type    X;
106     Type    Y;
107     Type    Z;
108 
109     Type& operator[] ( const int i )
110     {
111         ASSERT( i >= 0 );
112         ASSERT( i <= 2 );
113         return( ((Type*)this)[i] );
114     }
115 
116     const Type& operator[] ( const int i ) const
117     {
118         ASSERT( i >= 0 );
119         ASSERT( i <= 2 );
120         return( ((Type*)this)[i] );
121     }
122 
123     bool operator == ( const SVector3& vector ) const
124     {
125         return ( ( X == vector.X ) &&
126             ( Y == vector.Y ) &&
127             ( Z == vector.Z ) );
128     }
129 
130     bool operator != ( const SVector3& vector ) const
131     {
132         return ( ( X != vector.X ) ||
133             ( Y != vector.Y ) ||
134             ( Z != vector.Z ) );
135     }
136 };
137 
138 // Specialization of SVector3 template for Type float :
139 template<>
140 struct SVector3<float>
141 {
142     float    X;
143     float    Y;
144     float    Z;
145 
146     float& operator[] ( const int i )
147     {
148         ASSERT( i >= 0 );
149         ASSERT( i <= 2 );
150         return( ((float *)this)[i] );
151     }
152 
153     const float& operator[] ( const int i ) const
154     {
155         ASSERT( i >= 0 );
156         ASSERT( i <= 2 );
157         return( ((float *)this)[i] );
158     }
159 
160     bool operator == ( const SVector3<float>& vector ) const
161     {
162         return ( ( *(DWORD*)&X == *(DWORD*)&vector.X ) &&
163                  ( *(DWORD*)&Y == *(DWORD*)&vector.Y ) &&
164                  ( *(DWORD*)&Z == *(DWORD*)&vector.Z ) );
165     }
166 
167     bool operator != ( const SVector3& vector ) const
168     {
169         return ( ( *(DWORD*)&X != *(DWORD*)&vector.X ) ||
170                  ( *(DWORD*)&Y != *(DWORD*)&vector.Y ) ||
171                  ( *(DWORD*)&Z != *(DWORD*)&vector.Z ) );
172     }
173 };
174 
175 } // iSTD
176