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