Leviathan  0.8.0.0
Leviathan game engine
Leviathan::Float3 Struct Reference

#include <Types.h>

Public Member Functions

DLLEXPORT constexpr Float3 () noexcept=default
 
DLLEXPORT constexpr Float3 (float x, float y, float z) noexcept
 
DLLEXPORT constexpr Float3 (Float2 floats, float z) noexcept
 
DLLEXPORT constexpr Float3 (float data) noexcept
 
DLLEXPORT Float3 (const Int3 &values) noexcept
 
DLLEXPORT bool HasInvalidValues () const noexcept
 
DLLEXPORT void CheckForNans () const
 
DLLEXPORT float & operator[] (unsigned nindex)
 
DLLEXPORT float operator[] (unsigned nindex) const
 
DLLEXPORT constexpr Float3 operator+ (const Float3 &other) const noexcept
 
DLLEXPORT constexpr Float3operator+= (const Float3 &other) noexcept
 
DLLEXPORT constexpr Float3 operator- (const Float3 &other) const noexcept
 
DLLEXPORT constexpr Float3operator-= (const Float3 &other) noexcept
 
DLLEXPORT constexpr Float3 operator- () const noexcept
 
DLLEXPORT constexpr Float3 operator+ () const noexcept
 
DLLEXPORT constexpr Float3 operator* (const Float3 &other) const noexcept
 
DLLEXPORT constexpr Float3operator*= (const Float3 &other) noexcept
 
DLLEXPORT constexpr Float3 operator/ (float val) const
 
DLLEXPORT constexpr Float3operator/= (float val)
 
DLLEXPORT constexpr Float3 operator* (float val) const noexcept
 
DLLEXPORT constexpr Float3operator*= (float val) noexcept
 
DLLEXPORT constexpr Float3 operator/ (const Float3 &other) const
 
DLLEXPORT constexpr Float3operator/= (const Float3 &other)
 
DLLEXPORT bool operator< (const Float3 &other) const noexcept
 
DLLEXPORT bool operator<= (const Float3 &other) const noexcept
 
DLLEXPORT bool operator> (const Float3 &other) const noexcept
 
DLLEXPORT bool operator>= (const Float3 &other) const noexcept
 
DLLEXPORT bool operator== (const Float3 &other) const noexcept
 
DLLEXPORT bool operator!= (const Float3 &other) const noexcept
 
DLLEXPORT float GetX () const noexcept
 
DLLEXPORT float GetY () const noexcept
 
DLLEXPORT float GetZ () const noexcept
 
DLLEXPORT void SetX (float val)
 
DLLEXPORT void SetY (float val)
 
DLLEXPORT void SetZ (float val)
 
DLLEXPORT float HAdd () const noexcept
 
DLLEXPORT float HAddAbs () const noexcept
 
DLLEXPORT Float3 MinElements (const Float3 &other) const noexcept
 
DLLEXPORT Float3 MaxElements (const Float3 &other) const noexcept
 
DLLEXPORT Float3 Clamp (const Float3 &min, const Float3 &max) const noexcept
 
DLLEXPORT Float3 DegreesToRadians () const noexcept
 
DLLEXPORT constexpr float Dot (const Float3 &val) const noexcept
 
DLLEXPORT constexpr Float3 Cross (const Float3 &val) const
 
DLLEXPORT float Length () const noexcept
 
DLLEXPORT constexpr float LengthSquared () const noexcept
 
DLLEXPORT Float3 Normalize () const
 
DLLEXPORT Float3 NormalizeSafe (const Float3 &safer=Float3(1, 0, 0)) const noexcept
 
DLLEXPORT bool IsNormalized () const noexcept
 
DLLEXPORT Float3 Lerp (const Float3 &other, float f) const noexcept
 
DLLEXPORT bool Compare (const Float3 &other, float tolerance) const noexcept
 
DLLEXPORT Float3 (const bs::Vector3 &vec)
 
DLLEXPORT operator bs::Vector3 () const
 
DLLEXPORT Float3 (const btVector3 &vec)
 
DLLEXPORT operator btVector3 () const
 
 VALUE_TYPE (Float3)
 

Static Public Member Functions

static DLLEXPORT Float3 CreateVectorFromAngles (const float &yaw, const float &pitch) noexcept
 

Public Attributes

float X = 0
 
float Y = 0
 
float Z = 0
 

Static Public Attributes

static DLLEXPORT const Float3 UnitVForward = Float3(0.f, 0.f, -1.f)
 
static DLLEXPORT const Float3 UnitVUp = Float3(0.f, 1.f, 0.f)
 
static DLLEXPORT const Float3 Zeroed = Float3()
 
static DLLEXPORT const Float3 UnitXAxis = Float3(1.f, 0.f, 0.f)
 
static DLLEXPORT const Float3 UnitYAxis = Float3(0.f, 1.f, 0.f)
 
static DLLEXPORT const Float3 UnitZAxis = Float3(0.f, 0.f, 1.f)
 

Detailed Description

Definition at line 954 of file Types.h.

Constructor & Destructor Documentation

◆ Float3() [1/7]

DLLEXPORT constexpr Leviathan::Float3::Float3 ( )
inlinedefaultnoexcept

◆ Float3() [2/7]

DLLEXPORT constexpr Leviathan::Float3::Float3 ( float  x,
float  y,
float  z 
)
inlinenoexcept

Definition at line 958 of file Types.h.

958  : X(x), Y(y), Z(z)
959  {
960  DO_NAN_CHECK;
961  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ Float3() [3/7]

DLLEXPORT constexpr Leviathan::Float3::Float3 ( Float2  floats,
float  z 
)
inlinenoexcept

Definition at line 963 of file Types.h.

963  :
964  X(floats.X), Y(floats.Y), Z(z)
965  {
966  DO_NAN_CHECK;
967  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ Float3() [4/7]

DLLEXPORT constexpr Leviathan::Float3::Float3 ( float  data)
inlineexplicitnoexcept

Definition at line 969 of file Types.h.

969  : X(data), Y(data), Z(data)
970  {
971  DO_NAN_CHECK;
972  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ Float3() [5/7]

DLLEXPORT Leviathan::Float3::Float3 ( const Int3 values)
inlinenoexcept

Definition at line 974 of file Types.h.

974  :
975  X(static_cast<float>(values.X)), Y(static_cast<float>(values.Y)),
976  Z(static_cast<float>(values.Z))
977  {
978  DO_NAN_CHECK;
979  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ Float3() [6/7]

DLLEXPORT Leviathan::Float3::Float3 ( const bs::Vector3 &  vec)
inline

Definition at line 1300 of file Types.h.

1300  :
1301  // copy values //
1302  X(vec.x), Y(vec.y), Z(vec.z)
1303  {
1304  DO_NAN_CHECK;
1305  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ Float3() [7/7]

DLLEXPORT Leviathan::Float3::Float3 ( const btVector3 &  vec)
inline

Definition at line 1312 of file Types.h.

1312  :
1313  // copy values //
1314  X(vec.x()), Y(vec.y()), Z(vec.z())
1315  {
1316  DO_NAN_CHECK;
1317  }
#define DO_NAN_CHECK
Definition: Types.h:20

Member Function Documentation

◆ CheckForNans()

DLLEXPORT void Leviathan::Float3::CheckForNans ( ) const
inline

Definition at line 986 of file Types.h.

987  {
988  if(HasInvalidValues()) {
989  DEBUG_BREAK;
990  throw std::runtime_error("Float3 has NaNs (or infinites in it) in it!");
991  }
992  }
DLLEXPORT bool HasInvalidValues() const noexcept
Definition: Types.h:981

◆ Clamp()

DLLEXPORT Float3 Leviathan::Float3::Clamp ( const Float3 min,
const Float3 max 
) const
inlinenoexcept

Definition at line 1214 of file Types.h.

1215  {
1216  const Float3 minval = this->MinElements(max);
1217  return min.MaxElements(minval);
1218  }
DLLEXPORT constexpr Float3() noexcept=default
DLLEXPORT Float3 MinElements(const Float3 &other) const noexcept
Definition: Types.h:1201

◆ Compare()

DLLEXPORT bool Leviathan::Float3::Compare ( const Float3 other,
float  tolerance 
) const
inlinenoexcept

Definition at line 1284 of file Types.h.

1285  {
1286  const Float3 difference = (*this) - other;
1287  return difference.Dot(difference) < tolerance * tolerance;
1288  }
DLLEXPORT constexpr Float3() noexcept=default

◆ CreateVectorFromAngles()

static DLLEXPORT Float3 Leviathan::Float3::CreateVectorFromAngles ( const float &  yaw,
const float &  pitch 
)
inlinestaticnoexcept

Definition at line 1290 of file Types.h.

1292  {
1293  return Float3(-sin(yaw * DEGREES_TO_RADIANS), sin(pitch * DEGREES_TO_RADIANS),
1294  -cos(yaw * DEGREES_TO_RADIANS))
1295  .NormalizeSafe(Zeroed);
1296  }
static DLLEXPORT const Float3 Zeroed
Definition: Types.h:1335
constexpr float DEGREES_TO_RADIANS
Definition: Define.h:68
DLLEXPORT constexpr Float3() noexcept=default

◆ Cross()

DLLEXPORT constexpr Float3 Leviathan::Float3::Cross ( const Float3 val) const
inline

Definition at line 1233 of file Types.h.

1234  {
1235  return Float3(Y * val.Z - val.Y * Z, Z * val.X - val.Z * X, X * val.Y - val.X * Y);
1236  }
DLLEXPORT constexpr Float3() noexcept=default

◆ DegreesToRadians()

DLLEXPORT Float3 Leviathan::Float3::DegreesToRadians ( ) const
inlinenoexcept

Definition at line 1220 of file Types.h.

1221  {
1223  }
constexpr float DEGREES_TO_RADIANS
Definition: Define.h:68
DLLEXPORT constexpr Float3() noexcept=default

◆ Dot()

DLLEXPORT constexpr float Leviathan::Float3::Dot ( const Float3 val) const
inlinenoexcept

Definition at line 1227 of file Types.h.

1228  {
1229  return X * val.X + Y * val.Y + Z * val.Z;
1230  }

◆ GetX()

DLLEXPORT float Leviathan::Float3::GetX ( ) const
inlinenoexcept

Definition at line 1154 of file Types.h.

1155  {
1156  return X;
1157  }

◆ GetY()

DLLEXPORT float Leviathan::Float3::GetY ( ) const
inlinenoexcept

Definition at line 1159 of file Types.h.

1160  {
1161  return Y;
1162  }

◆ GetZ()

DLLEXPORT float Leviathan::Float3::GetZ ( ) const
inlinenoexcept

Definition at line 1164 of file Types.h.

1165  {
1166  return Z;
1167  }

◆ HAdd()

DLLEXPORT float Leviathan::Float3::HAdd ( ) const
inlinenoexcept

Definition at line 1189 of file Types.h.

1190  {
1191  return X + Y + Z;
1192  }

◆ HAddAbs()

DLLEXPORT float Leviathan::Float3::HAddAbs ( ) const
inlinenoexcept

Definition at line 1195 of file Types.h.

1196  {
1197  return std::abs(X) + std::abs(Y) + std::abs(Z);
1198  }

◆ HasInvalidValues()

DLLEXPORT bool Leviathan::Float3::HasInvalidValues ( ) const
inlinenoexcept

Definition at line 981 of file Types.h.

982  {
983  return !std::isfinite(X) || !std::isfinite(Y) || !std::isfinite(Z);
984  }
#define isfinite
Definition: jsoncpp.cpp:4247

◆ IsNormalized()

DLLEXPORT bool Leviathan::Float3::IsNormalized ( ) const
inlinenoexcept

Definition at line 1270 of file Types.h.

1271  {
1272  // is absolute -1.f under normalization tolerance //
1273  return fabs(X * X + Y * Y + Z * Z - 1.0f) < NORMALIZATION_TOLERANCE;
1274  }
constexpr float NORMALIZATION_TOLERANCE
For checking vector normalization.
Definition: Define.h:50

◆ Length()

DLLEXPORT float Leviathan::Float3::Length ( ) const
inlinenoexcept

Definition at line 1239 of file Types.h.

1240  {
1241  return std::sqrt(LengthSquared());
1242  }
DLLEXPORT constexpr float LengthSquared() const noexcept
Definition: Types.h:1244

◆ LengthSquared()

DLLEXPORT constexpr float Leviathan::Float3::LengthSquared ( ) const
inlinenoexcept

Definition at line 1244 of file Types.h.

1245  {
1246  return X * X + Y * Y + Z * Z;
1247  }

◆ Lerp()

DLLEXPORT Float3 Leviathan::Float3::Lerp ( const Float3 other,
float  f 
) const
inlinenoexcept

Definition at line 1278 of file Types.h.

1279  {
1280  return Float3((other.X - X) * f + X, (other.Y - Y) * f + Y, (other.Z - Z) * f + Z);
1281  }
DLLEXPORT constexpr Float3() noexcept=default

◆ MaxElements()

DLLEXPORT Float3 Leviathan::Float3::MaxElements ( const Float3 other) const
inlinenoexcept

Definition at line 1207 of file Types.h.

1208  {
1209  return Float3(
1210  X > other.X ? X : other.X, Y > other.Y ? Y : other.Y, Z > other.Z ? Z : other.Z);
1211  }
DLLEXPORT constexpr Float3() noexcept=default

◆ MinElements()

DLLEXPORT Float3 Leviathan::Float3::MinElements ( const Float3 other) const
inlinenoexcept

Definition at line 1201 of file Types.h.

1202  {
1203  return Float3(
1204  X < other.X ? X : other.X, Y < other.Y ? Y : other.Y, Z < other.Z ? Z : other.Z);
1205  }
DLLEXPORT constexpr Float3() noexcept=default

◆ Normalize()

DLLEXPORT Float3 Leviathan::Float3::Normalize ( ) const
inline

Definition at line 1250 of file Types.h.

1251  {
1252  const float length = Length();
1253  if(length == 0)
1254  return Float3(0, 0, 0);
1255  return (*this) / length;
1256  }
DLLEXPORT float Length() const noexcept
Definition: Types.h:1239
DLLEXPORT constexpr Float3() noexcept=default

◆ NormalizeSafe()

DLLEXPORT Float3 Leviathan::Float3::NormalizeSafe ( const Float3 safer = Float3(1, 0, 0)) const
inlinenoexcept

Definition at line 1259 of file Types.h.

1260  {
1261  // security //
1262  LEVIATHAN_ASSERT(safer.IsNormalized(), "safer not normalized");
1263  if(LengthSquared() == 0)
1264  return safer;
1265  const float length = Length();
1266  return (*this) / length;
1267  }
DLLEXPORT float Length() const noexcept
Definition: Types.h:1239
DLLEXPORT constexpr float LengthSquared() const noexcept
Definition: Types.h:1244
#define LEVIATHAN_ASSERT(x, msg)
Definition: Define.h:100

◆ operator bs::Vector3()

DLLEXPORT Leviathan::Float3::operator bs::Vector3 ( ) const
inline

Definition at line 1307 of file Types.h.

1308  {
1309  return bs::Vector3(X, Y, Z);
1310  }

◆ operator btVector3()

DLLEXPORT Leviathan::Float3::operator btVector3 ( ) const
inline

Definition at line 1319 of file Types.h.

1320  {
1321  return btVector3(X, Y, Z);
1322  }

◆ operator!=()

DLLEXPORT bool Leviathan::Float3::operator!= ( const Float3 other) const
inlinenoexcept

Definition at line 1147 of file Types.h.

1148  {
1149  return X != other.X || Y != other.Y || Z != other.Z;
1150  }

◆ operator*() [1/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator* ( const Float3 other) const
inlinenoexcept

Definition at line 1061 of file Types.h.

1062  {
1063  return Float3(X * other.X, Y * other.Y, Z * other.Z);
1064  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator*() [2/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator* ( float  val) const
inlinenoexcept

Definition at line 1091 of file Types.h.

1092  {
1093  return Float3(X * val, Y * val, Z * val);
1094  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator*=() [1/2]

DLLEXPORT constexpr Float3& Leviathan::Float3::operator*= ( const Float3 other)
inlinenoexcept

Definition at line 1066 of file Types.h.

1067  {
1068  X *= other.X;
1069  Y *= other.Y;
1070  Z *= other.Z;
1071  DO_NAN_CHECK;
1072  return *this;
1073  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ operator*=() [2/2]

DLLEXPORT constexpr Float3& Leviathan::Float3::operator*= ( float  val)
inlinenoexcept

Definition at line 1096 of file Types.h.

1097  {
1098  X *= val;
1099  Y *= val;
1100  Z *= val;
1101  DO_NAN_CHECK;
1102  return *this;
1103  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ operator+() [1/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator+ ( const Float3 other) const
inlinenoexcept

Definition at line 1021 of file Types.h.

1022  {
1023  return Float3(X + other.X, Y + other.Y, Z + other.Z);
1024  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator+() [2/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator+ ( ) const
inlinenoexcept

Definition at line 1055 of file Types.h.

1056  {
1057  return Float3(*this);
1058  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator+=()

DLLEXPORT constexpr Float3& Leviathan::Float3::operator+= ( const Float3 other)
inlinenoexcept

Definition at line 1026 of file Types.h.

1027  {
1028  X += other.X;
1029  Y += other.Y;
1030  Z += other.Z;
1031  return *this;
1032  }

◆ operator-() [1/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator- ( const Float3 other) const
inlinenoexcept

Definition at line 1035 of file Types.h.

1036  {
1037  return Float3(X - other.X, Y - other.Y, Z - other.Z);
1038  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator-() [2/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator- ( ) const
inlinenoexcept

Definition at line 1049 of file Types.h.

1050  {
1051  return Float3(-X, -Y, -Z);
1052  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator-=()

DLLEXPORT constexpr Float3& Leviathan::Float3::operator-= ( const Float3 other)
inlinenoexcept

Definition at line 1040 of file Types.h.

1041  {
1042  X -= other.X;
1043  Y -= other.Y;
1044  Z -= other.Z;
1045  return *this;
1046  }

◆ operator/() [1/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator/ ( float  val) const
inline

Definition at line 1076 of file Types.h.

1077  {
1078  return Float3(X / val, Y / val, Z / val);
1079  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator/() [2/2]

DLLEXPORT constexpr Float3 Leviathan::Float3::operator/ ( const Float3 other) const
inline

Definition at line 1106 of file Types.h.

1107  {
1108  return Float3(X / other.X, Y / other.Y, Z / other.Z);
1109  }
DLLEXPORT constexpr Float3() noexcept=default

◆ operator/=() [1/2]

DLLEXPORT constexpr Float3& Leviathan::Float3::operator/= ( float  val)
inline

Definition at line 1081 of file Types.h.

1082  {
1083  X /= val;
1084  Y /= val;
1085  Z /= val;
1086  DO_NAN_CHECK;
1087  return *this;
1088  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ operator/=() [2/2]

DLLEXPORT constexpr Float3& Leviathan::Float3::operator/= ( const Float3 other)
inline

Definition at line 1111 of file Types.h.

1112  {
1113  X /= other.X;
1114  Y /= other.Y;
1115  Z /= other.Z;
1116  DO_NAN_CHECK;
1117  return *this;
1118  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ operator<()

DLLEXPORT bool Leviathan::Float3::operator< ( const Float3 other) const
inlinenoexcept

Definition at line 1122 of file Types.h.

1123  {
1124  return std::tie(X, Y, Z) < std::tie(other.X, other.Y, other.Z);
1125  }

◆ operator<=()

DLLEXPORT bool Leviathan::Float3::operator<= ( const Float3 other) const
inlinenoexcept

Definition at line 1127 of file Types.h.

1128  {
1129  return std::tie(X, Y, Z) <= std::tie(other.X, other.Y, other.Z);
1130  }

◆ operator==()

DLLEXPORT bool Leviathan::Float3::operator== ( const Float3 other) const
inlinenoexcept

Definition at line 1142 of file Types.h.

1143  {
1144  return X == other.X && Y == other.Y && Z == other.Z;
1145  }

◆ operator>()

DLLEXPORT bool Leviathan::Float3::operator> ( const Float3 other) const
inlinenoexcept

Definition at line 1132 of file Types.h.

1133  {
1134  return std::tie(X, Y, Z) > std::tie(other.X, other.Y, other.Z);
1135  }

◆ operator>=()

DLLEXPORT bool Leviathan::Float3::operator>= ( const Float3 other) const
inlinenoexcept

Definition at line 1137 of file Types.h.

1138  {
1139  return std::tie(X, Y, Z) >= std::tie(other.X, other.Y, other.Z);
1140  }

◆ operator[]() [1/2]

DLLEXPORT float& Leviathan::Float3::operator[] ( unsigned  nindex)
inline

Definition at line 995 of file Types.h.

996  {
997  switch(nindex) {
998  case 0: return X;
999  case 1: return Y;
1000  case 2: return Z;
1001  default: break;
1002  }
1003  LEVIATHAN_ASSERT(0, "invalid [] access");
1004  return X;
1005  }
#define LEVIATHAN_ASSERT(x, msg)
Definition: Define.h:100

◆ operator[]() [2/2]

DLLEXPORT float Leviathan::Float3::operator[] ( unsigned  nindex) const
inline

Definition at line 1007 of file Types.h.

1008  {
1009  switch(nindex) {
1010  case 0: return X;
1011  case 1: return Y;
1012  case 2: return Z;
1013  default: break;
1014  }
1015  LEVIATHAN_ASSERT(0, "invalid [] access");
1016  return X;
1017  }
#define LEVIATHAN_ASSERT(x, msg)
Definition: Define.h:100

◆ SetX()

DLLEXPORT void Leviathan::Float3::SetX ( float  val)
inline

Definition at line 1170 of file Types.h.

1171  {
1172  X = val;
1173  DO_NAN_CHECK;
1174  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ SetY()

DLLEXPORT void Leviathan::Float3::SetY ( float  val)
inline

Definition at line 1176 of file Types.h.

1177  {
1178  Y = val;
1179  DO_NAN_CHECK;
1180  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ SetZ()

DLLEXPORT void Leviathan::Float3::SetZ ( float  val)
inline

Definition at line 1182 of file Types.h.

1183  {
1184  Z = val;
1185  DO_NAN_CHECK;
1186  }
#define DO_NAN_CHECK
Definition: Types.h:20

◆ VALUE_TYPE()

Leviathan::Float3::VALUE_TYPE ( Float3  )

Member Data Documentation

◆ UnitVForward

DLLEXPORT const Float3 Leviathan::Float3::UnitVForward = Float3(0.f, 0.f, -1.f)
static

Definition at line 1333 of file Types.h.

◆ UnitVUp

DLLEXPORT const Float3 Leviathan::Float3::UnitVUp = Float3(0.f, 1.f, 0.f)
static

Definition at line 1334 of file Types.h.

◆ UnitXAxis

DLLEXPORT const Float3 Leviathan::Float3::UnitXAxis = Float3(1.f, 0.f, 0.f)
static

Definition at line 1336 of file Types.h.

◆ UnitYAxis

DLLEXPORT const Float3 Leviathan::Float3::UnitYAxis = Float3(0.f, 1.f, 0.f)
static

Definition at line 1337 of file Types.h.

◆ UnitZAxis

DLLEXPORT const Float3 Leviathan::Float3::UnitZAxis = Float3(0.f, 0.f, 1.f)
static

Definition at line 1338 of file Types.h.

◆ X

float Leviathan::Float3::X = 0

Definition at line 1329 of file Types.h.

◆ Y

float Leviathan::Float3::Y = 0

Definition at line 1330 of file Types.h.

◆ Z

float Leviathan::Float3::Z = 0

Definition at line 1331 of file Types.h.

◆ Zeroed

DLLEXPORT const Float3 Leviathan::Float3::Zeroed = Float3()
static

Definition at line 1335 of file Types.h.


The documentation for this struct was generated from the following files: