431 template <
typename TYPE>
535 this->
object->Release();
649 this->
f[0] = rhs.
f[0];
658 this->
f[0] = rhs.
f[0];
659 this->
f[1] = rhs.
f[1];
662 this->
f[0] = rhs.
f[0];
663 this->
f[1] = rhs.
f[1];
664 this->
f[2] = rhs.
f[2];
667 this->
f[0] = rhs.
f[0];
668 this->
f[1] = rhs.
f[1];
669 this->
f[2] = rhs.
f[2];
670 this->
f[3] = rhs.
f[3];
673 this->
f[0] = rhs.
f[0];
674 this->
f[1] = rhs.
f[1];
675 this->
f[2] = rhs.
f[2];
676 this->
f[3] = rhs.
f[3];
694 this->
object = rhs.
object;
697 this->
object->AddRef();
734 n_error(
"Variant::Copy(): invalid type!");
929 this->
object->AddRef();
1451 this->
object->AddRef();
1653 if (rhs.
type == this->type)
1660 return (this->
i8 == rhs.
i8);
1662 return (this->
i16 == rhs.
i16);
1666 return (this->
i == rhs.
i);
1668 return (this->
u == rhs.
u);
1670 return (this->
i64 == rhs.
i64);
1672 return (this->
u64 == rhs.
u64);
1674 return (this->
b == rhs.
b);
1676 return (this->
f[0] == rhs.
f[0]);
1678 return (this->
d == rhs.
d);
1680 return ((*this->
string) == (*rhs.
string));
1682 return ((this->
f[0] == rhs.
f[0]) && (this->f[1] == rhs.
f[1]));
1684 return ((this->
f[0] == rhs.
f[0]) &&
1685 (this->f[1] == rhs.
f[1]) &&
1686 (this->f[2] == rhs.
f[2]) &&
1687 (this->f[3] == rhs.
f[3]));
1689 return ((this->
f[0] == rhs.
f[0]) &&
1690 (this->f[1] == rhs.
f[1]) &&
1691 (this->f[2] == rhs.
f[2]) &&
1692 (this->f[3] == rhs.
f[3]));
1694 return ((*this->
guid) == (*rhs.
guid));
1696 return ((*this->
blob) == (*rhs.
blob));
1698 return (this->
object == rhs.
object);
1702 return ((*this->
m) == (*rhs.
m));
1704 return ((*this->
t) == (*rhs.
t));
1706 n_error(
"Variant::operator==(): invalid variant type!");
1719 if (rhs.
type == this->type)
1726 return (this->
i8 > rhs.
i8);
1728 return (this->
i16 > rhs.
i16);
1732 return (this->
i > rhs.
i);
1734 return (this->
u > rhs.
u);
1736 return (this->
i64 > rhs.
i64);
1738 return (this->
u64 > rhs.
u64);
1740 return (this->
b > rhs.
b);
1742 return (this->
f[0] > rhs.
f[0]);
1744 return (this->
d > rhs.
d);
1746 return ((*this->
string) > (*rhs.
string));
1748 return ((this->
f[0] > rhs.
f[0]) && (this->f[1] > rhs.
f[1]));
1750 return ((this->
f[0] > rhs.
f[0]) &&
1751 (this->f[1] > rhs.
f[1]) &&
1752 (this->f[2] > rhs.
f[2]) &&
1753 (this->f[3] > rhs.
f[3]));
1755 return ((this->
f[0] > rhs.
f[0]) &&
1756 (this->f[1] > rhs.
f[1]) &&
1757 (this->f[2] > rhs.
f[2]) &&
1758 (this->f[3] > rhs.
f[3]));
1760 return ((*this->
guid) > (*rhs.
guid));
1762 return ((*this->
blob) > (*rhs.
blob));
1764 return (this->
object > rhs.
object);
1768 n_error(
"Variant::operator>(): invalid variant type!");
1781 if (rhs.
type == this->type)
1788 return (this->
i8 < rhs.
i8);
1790 return (this->
i16 < rhs.
i16);
1794 return (this->
i < rhs.
i);
1796 return (this->
u < rhs.
u);
1798 return (this->
i64 < rhs.
i64);
1800 return (this->
u64 < rhs.
u64);
1802 return (this->
b < rhs.
b);
1804 return (this->
f[0] < rhs.
f[0]);
1806 return (this->
d > rhs.
d);
1808 return ((*this->
string) < (*rhs.
string));
1810 return ((this->
f[0] < rhs.
f[0]) && (this->f[1] < rhs.
f[1]));
1812 return ((this->
f[0] < rhs.
f[0]) &&
1813 (this->f[1] < rhs.
f[1]) &&
1814 (this->f[2] < rhs.
f[2]) &&
1815 (this->f[3] < rhs.
f[3]));
1817 return ((this->
f[0] < rhs.
f[0]) &&
1818 (this->f[1] < rhs.
f[1]) &&
1819 (this->f[2] < rhs.
f[2]) &&
1820 (this->f[3] < rhs.
f[3]));
1822 return ((*this->
guid) < (*rhs.
guid));
1824 return ((*this->
blob) < (*rhs.
blob));
1826 return (this->
object < rhs.
object);
1830 n_error(
"Variant::operator<(): invalid variant type!");
1844 if (rhs.
type == this->type)
1851 return (this->
i8 >= rhs.
i8);
1853 return (this->
i16 >= rhs.
i16);
1857 return (this->
i >= rhs.
i);
1859 return (this->
u >= rhs.
u);
1861 return (this->
i64 >= rhs.
i64);
1863 return (this->
u64 >= rhs.
u64);
1865 return (this->
b >= rhs.
b);
1867 return (this->
f[0] >= rhs.
f[0]);
1869 return (this->
d >= rhs.
d);
1871 return ((*this->
string) >= (*rhs.
string));
1873 return ((this->
f[0] >= rhs.
f[0]) && (this->f[1] >= rhs.
f[1]));
1875 return ((this->
f[0] >= rhs.
f[0]) &&
1876 (this->f[1] >= rhs.
f[1]) &&
1877 (this->f[2] >= rhs.
f[2]) &&
1878 (this->f[3] >= rhs.
f[3]));
1880 return ((this->
f[0] >= rhs.
f[0]) &&
1881 (this->f[1] >= rhs.
f[1]) &&
1882 (this->f[2] >= rhs.
f[2]) &&
1883 (this->f[3] >= rhs.
f[3]));
1885 return ((*this->
guid) >= (*rhs.
guid));
1887 return ((*this->
blob) >= (*rhs.
blob));
1889 return (this->
object >= rhs.
object);
1893 n_error(
"Variant::operator>(): invalid variant type!");
1906 if (rhs.
type == this->type)
1913 return (this->
i8 <= rhs.
i8);
1915 return (this->
i16 <= rhs.
i16);
1919 return (this->
i <= rhs.
i);
1921 return (this->
u <= rhs.
u);
1923 return (this->
i64 <= rhs.
i64);
1925 return (this->
u64 <= rhs.
u64);
1927 return (this->
b <= rhs.
b);
1929 return (this->
f[0] <= rhs.
f[0]);
1931 return (this->
d >= rhs.
d);
1933 return ((*this->
string) <= (*rhs.
string));
1935 return ((this->
f[0] <= rhs.
f[0]) && (this->f[1] <= rhs.
f[1]));
1937 return ((this->
f[0] <= rhs.
f[0]) &&
1938 (this->f[1] <= rhs.
f[1]) &&
1939 (this->f[2] <= rhs.
f[2]) &&
1940 (this->f[3] <= rhs.
f[3]));
1942 return ((this->
f[0] <= rhs.
f[0]) &&
1943 (this->f[1] <= rhs.
f[1]) &&
1944 (this->f[2] <= rhs.
f[2]) &&
1945 (this->f[3] <= rhs.
f[3]));
1947 return ((*this->
guid) <= (*rhs.
guid));
1949 return ((*this->
blob) <= (*rhs.
blob));
1951 return (this->
object <= rhs.
object);
1955 n_error(
"Variant::operator<(): invalid variant type!");
1968 return !(*
this == rhs);
1978 return (this->
i8 == rhs);
1988 return (this->
i16 == rhs);
1998 return (this->
ui16 == rhs);
2008 return (this->
i == rhs);
2018 return (this->
u == rhs);
2028 return (this->
i64 == rhs);
2038 return (this->
u64 == rhs);
2048 return (this->
f[0] == rhs);
2058 return (this->
d == rhs);
2068 return (this->
b == rhs);
2078 return ((*this->
string) == rhs);
2098 return (this->
f[0] == rhs.
x && this->f[1] == rhs.
y);
2108 return ((this->
f[0] == rhs.
x) &&
2109 (this->f[1] == rhs.
y) &&
2110 (this->f[2] == rhs.
z) &&
2111 (this->f[3] == rhs.
w));
2121 return ((this->
f[0] == rhs.
x) &&
2122 (this->f[1] == rhs.
y) &&
2123 (this->f[2] == rhs.
z) &&
2124 (this->f[3] == rhs.
w));
2134 return (*this->
guid) == rhs;
2144 return this->
object == ptr;
2164 return (this->
i8 != rhs);
2174 return (this->
i16 != rhs);
2184 return (this->
ui16 != rhs);
2194 return (this->
i != rhs);
2204 return (this->
u != rhs);
2214 return (this->
i64 != rhs);
2224 return (this->
u64 != rhs);
2234 return (this->
f[0] != rhs);
2244 return (this->
d != rhs);
2254 return (this->
b != rhs);
2264 return (*this->
string) != rhs;
2284 return (this->
f[0] != rhs.
x || this->f[1] != rhs.
y);
2294 return ((this->
f[0] != rhs.
x) ||
2295 (this->f[1] != rhs.
y) ||
2296 (this->f[2] != rhs.
z) ||
2297 (this->f[3] != rhs.
w));
2307 return ((this->
f[0] != rhs.
x) ||
2308 (this->f[1] != rhs.
y) ||
2309 (this->f[2] != rhs.
z) ||
2310 (this->f[3] != rhs.
w));
2320 return (*this->
guid) != rhs;
2330 return (this->
object == ptr);
2340 return (this->
voidPtr == ptr);
2607 return Math::vec4(this->
f[0], this->
f[1], this->
f[2], this->
f[3]);
2626 return Math::quat(this->
f[0], this->
f[1], this->
f[2], this->
f[3]);
2683 return *(this->
guid);
2702 return *(this->
blob);
2740 return this->voidPtr;
2936template <
typename TYPE>
2940 static_assert(
true,
"Get method for TYPE is not implemented!");
3251 case Guid: { retval = this->
GetGuid().AsString();
break; }
3257 n_error(
"Variant::ToString(): invalid type enum '%d'", this->
type);
3271 bool retval =
false;
3275 case UInt: {
if(
string.IsValidInt()) { this->SetUInt(
string.AsInt()); retval =
true; }
break; };
3276 case Float: {
if(
string.IsValidFloat()) { this->SetFloat(
string.AsFloat()); retval =
true; }
break; }
3277 case Bool: {
if(
string.IsValidBool()) { this->SetBool(
string.AsBool()); retval =
true; }
break; }
3278 case Vec2: {
if(
string.IsValidVec2()) { this->SetVec2(
string.AsVec2()); retval =
true; }
break; }
3279 case Vec4: {
if(
string.IsValidVec4()) { this->SetVec4(
string.AsVec4()); retval =
true; }
break; }
3280 case String: { this->SetString(
string); retval =
true;
break; }
3281 case Mat4: {
if(
string.IsValidMat4()) { this->SetMat4(
string.AsMat4()); retval =
true; }
break; }
3282 case Transform44: {
if (
string.IsValidTransform44()) { this->SetTransform44(
string.AsTransform44()); retval =
true; }
break; }
3289 for (i = 0; i < tokens.
Size(); i++)
3291 if (tokens[i].IsValidInt())
3293 result.
Append(tokens[i].AsInt());
3296 this->SetIntArray(result);
3305 for (i = 0; i < tokens.
Size(); i++)
3307 if (tokens[i].IsValidFloat())
3309 result.
Append(tokens[i].AsFloat());
3312 this->SetFloatArray(result);
3321 for (i = 0; i < tokens.
Size(); i++)
3323 if (tokens[i].IsValidBool())
3325 result.
Append(tokens[i].AsBool());
3328 this->SetBoolArray(result);
3335 this->SetStringArray(tokens);
3354 case Void:
return 0;
3362 case Float:
return sizeof(float);
3363 case Double:
return sizeof(double);
3364 case Bool:
return sizeof(bool);
3365 case Vec2:
return sizeof(float) * 2;
3366 case Vec4:
return sizeof(float) * 4;
3374 case VoidPtr:
return sizeof(
void*);
3385 n_error(
"Variant::Size(): invalid type enum '%d'!", this->
type);
3433 n_error(
"Variant::AsVoidPtr(): invalid type enum '%d'!", this->
type);
3446 if (
string.IsValidInt()) val.
SetInt(
string.AsInt());
3447 else if (
string.IsValidFloat()) val.
SetFloat(
string.AsFloat());
3448 else if (
string.IsValidVec2()) val.
SetVec2(
string.AsVec2());
3449 else if (
string.IsValidVec4()) val.
SetVec4(
string.AsVec4());
3450 else if (
string.IsValidBool()) val.
SetBool(
string.AsBool());
3451 else if (
string.IsValidMat4()) val.
SetMat4(
string.AsMat4());
3464 case Void:
return "void";
3465 case Byte:
return "byte";
3466 case Short:
return "short";
3467 case UShort:
return "ushort";
3468 case Int:
return "int";
3469 case UInt:
return "uint";
3470 case Int64:
return "int64";
3471 case UInt64:
return "uint64";
3472 case Float:
return "float";
3473 case Double:
return "double";
3474 case Bool:
return "bool";
3475 case Vec2:
return "vec2";
3476 case Vec4:
return "vec4";
3478 case String:
return "string";
3479 case Mat4:
return "mat4";
3481 case Blob:
return "blob";
3482 case Guid:
return "guid";
3483 case Object:
return "object";
3484 case VoidPtr:
return "voidptr";
3495 n_error(
"Variant::TypeToString(): invalid type enum '%d'!",
t);
3506 if (
"void" == str)
return Void;
3507 else if (
"byte" == str)
return Byte;
3508 else if (
"short" == str)
return Short;
3509 else if (
"ushort" == str)
return UShort;
3510 else if (
"int" == str)
return Int;
3511 else if (
"uint" == str)
return UInt;
3512 else if (
"int64" == str)
return Int64;
3513 else if (
"uint64" == str)
return UInt64;
3514 else if (
"float" == str)
return Float;
3515 else if (
"double" == str)
return Double;
3516 else if (
"bool" == str)
return Bool;
3517 else if (
"vec2" == str)
return Vec2;
3518 else if (
"vec4" == str)
return Vec4;
3519 else if (
"color" == str)
return Vec4;
3520 else if (
"quaternion" == str)
return Quaternion;
3521 else if (
"string" == str)
return String;
3522 else if (
"mat4" == str)
return Mat4;
3523 else if (
"transform44" == str)
return Transform44;
3524 else if (
"blob" == str)
return Blob;
3525 else if (
"guid" == str)
return Guid;
3526 else if (
"object" == str)
return Object;
3527 else if (
"voidptr" == str)
return VoidPtr;
3528 else if (
"intarray" == str)
return IntArray;
3529 else if (
"floatarray" == str)
return FloatArray;
3530 else if (
"boolarray" == str)
return BoolArray;
3531 else if (
"vec2array" == str)
return Vec2Array;
3532 else if (
"vec4array" == str)
return Vec4Array;
3533 else if (
"mat4array" == str)
return Mat4Array;
3534 else if (
"stringarray" == str)
return StringArray;
3535 else if (
"guidarray" == str)
return GuidArray;
3536 else if (
"blobarray" == str)
return BlobArray;
3539 n_error(
"Variant::StringToType(): invalid type string '%s'!", str.
AsCharPtr());
The common base class of Nebula.
Definition refcounted.h:38
Nebula's dynamic array class.
Definition array.h:60
void Append(const TYPE &first, const ELEM_TYPE &... elements)
Append multiple elements to the end of the array.
Definition array.h:1334
const SizeT Size() const
get number of elements in array
Definition array.h:880
The Util::Blob class encapsulates a chunk of raw memory into a C++ object which can be copied,...
Definition blob.h:22
An "any type" variable.
Definition variant.h:31
void SetDouble(double val)
set double content
Definition variant.h:2501
Util::Array< Math::mat4 > * mat4Array
Definition variant.h:483
const Util::Array< Util::String > & GetStringArray() const
get string array content
Definition variant.h:2889
void SetBlob(const Util::Blob &val)
set blob
Definition variant.h:2690
int64_t GetInt64() const
get integer content
Definition variant.h:2452
Core::RefCounted * object
Definition variant.h:476
const Math::mat4 & GetMat4() const
get mat4 content
Definition variant.h:2642
Math::quat GetQuat() const
get quaternion content
Definition variant.h:2623
Type
variant types
Definition variant.h:35
@ Short
Definition variant.h:38
@ BlobArray
Definition variant.h:66
@ UInt64
Definition variant.h:43
@ Int
Definition variant.h:40
@ Vec4Array
Definition variant.h:63
@ Quaternion
Definition variant.h:50
@ Blob
Definition variant.h:54
@ Vec3Array
Definition variant.h:62
@ Transform44
Definition variant.h:53
@ Float
Definition variant.h:44
@ Bool
Definition variant.h:46
@ FloatArray
Definition variant.h:59
@ Vec2
Definition variant.h:47
@ GuidArray
Definition variant.h:67
@ String
Definition variant.h:51
@ Object
Definition variant.h:56
@ StringArray
Definition variant.h:64
@ Void
Definition variant.h:36
@ NumTypes
Definition variant.h:68
@ UInt
Definition variant.h:41
@ IntArray
Definition variant.h:58
@ Mat4Array
Definition variant.h:65
@ Vec3
Definition variant.h:48
@ Guid
Definition variant.h:55
@ Double
Definition variant.h:45
@ Mat4
Definition variant.h:52
@ VoidPtr
Definition variant.h:57
@ Vec2Array
Definition variant.h:61
@ Int64
Definition variant.h:42
@ Byte
Definition variant.h:37
@ Vec4
Definition variant.h:49
@ UShort
Definition variant.h:39
@ BoolArray
Definition variant.h:60
const Util::Array< Math::mat4 > & GetMat4Array() const
get mat4 array content
Definition variant.h:2870
Math::vec4 GetVec4() const
get vec4 content
Definition variant.h:2604
int GetInt() const
get integer content
Definition variant.h:2422
double d
Definition variant.h:468
const Util::String & GetString() const
get string content
Definition variant.h:2548
bool operator>=(const Variant &rhs) const
greater equal operator
Definition variant.h:1842
void * voidPtr
Definition variant.h:475
bool b
Definition variant.h:467
void SetFloat(float val)
set float content
Definition variant.h:2482
Util::Guid * guid
Definition variant.h:473
uint GetUInt() const
get unsigned integer content
Definition variant.h:2432
void SetBool(bool val)
set bool content
Definition variant.h:2520
Math::transform44 * t
Definition variant.h:471
bool GetBool() const
get bool content
Definition variant.h:2529
void Clear()
clear content, resets type to void
Definition variant.h:610
static Variant FromString(const Util::String &string)
create from string
Definition variant.h:3443
Util::Blob * blob
Definition variant.h:474
void SetShort(short val)
set short content
Definition variant.h:2366
bool operator!=(const Variant &rhs) const
inequality operator
Definition variant.h:1966
void SetBoolArray(const Util::Array< bool > &val)
set bool array content
Definition variant.h:2785
void operator=(const Variant &rhs)
assignment operator
Definition variant.h:1181
const Util::Array< Math::vec3 > & GetVec3Array() const
get vec4 array content
Definition variant.h:2832
void SetByte(byte val)
set byte content
Definition variant.h:2347
Util::Array< bool > * boolArray
Definition variant.h:479
ushort ui16
Definition variant.h:462
void SetBlobArray(const Util::Array< Util::Blob > &val)
set blob array content
Definition variant.h:2918
void SetVec3Array(const Util::Array< Math::vec3 > &val)
set vec4 array content
Definition variant.h:2823
Variant()
default constructor
Definition variant.h:494
Util::Array< Util::Guid > * guidArray
Definition variant.h:485
Type GetType() const
get type
Definition variant.h:1172
void SetGuid(const Util::Guid &val)
set guid content
Definition variant.h:2671
void SetString(const Util::String &val)
set string content
Definition variant.h:2539
Util::Array< Util::Blob > * blobArray
Definition variant.h:486
const Util::Array< float > & GetFloatArray() const
get float array content
Definition variant.h:2775
void SetFloatArray(const Util::Array< float > &val)
set float array content
Definition variant.h:2766
void SetType(Type t)
set type of attribute
Definition variant.h:1106
void SetInt64(int64_t val)
set integer content
Definition variant.h:2442
TYPE Get() const
Templated get method.
Definition variant.h:2938
void SetMat4Array(const Util::Array< Math::mat4 > &val)
set mat4 array content
Definition variant.h:2861
void SetVec4Array(const Util::Array< Math::vec4 > &val)
set vec4 array content
Definition variant.h:2842
const Util::Array< Util::Blob > & GetBlobArray() const
get blob array content
Definition variant.h:2927
bool operator==(const Variant &rhs) const
equality operator
Definition variant.h:1651
const Util::Guid & GetGuid() const
get guid content
Definition variant.h:2680
void SetVec2(const Math::vec2 &val)
set vec2 content
Definition variant.h:2558
float GetFloat() const
get float content
Definition variant.h:2491
void SetUInt64(uint64_t val)
set unsigned integer content
Definition variant.h:2462
void SetVoidPtr(void *ptr)
set opaque void pointer
uint64_t GetUInt64() const
get unsigned integer content
Definition variant.h:2472
void SetVec2Array(const Util::Array< Math::vec2 > &val)
set vec2 array content
Definition variant.h:2804
void SetStringArray(const Util::Array< Util::String > &val)
set string array content
Definition variant.h:2880
const Util::Array< Util::Guid > & GetGuidArray() const
get guid array content
Definition variant.h:2908
Math::vec3 GetVec3() const
get vec4 content
Definition variant.h:2586
Util::Array< Math::vec4 > * vec4Array
Definition variant.h:482
const void * AsVoidPtr() const
get pointer to data
Definition variant.h:3395
static Type StringToType(const Util::String &str)
convert string to type
Definition variant.h:3504
void Delete()
delete current content
Definition variant.h:505
void SetIntArray(const Util::Array< int > &val)
set int array content
Definition variant.h:2747
Type type
Definition variant.h:457
const Math::transform44 & GetTransform44() const
get transform44 content
Definition variant.h:2661
Core::RefCounted * GetObject() const
get object pointer
Definition variant.h:2718
void SetQuat(const Math::quat &val)
set quaternion content
Definition variant.h:2614
Math::mat4 * m
Definition variant.h:470
bool operator<(const Variant &rhs) const
less operator
Definition variant.h:1779
const Util::Blob & GetBlob() const
get blob
Definition variant.h:2699
static Util::String TypeToString(Type t)
convert type to string
Definition variant.h:3460
short i16
Definition variant.h:461
Util::Array< float > * floatArray
Definition variant.h:478
int i
Definition variant.h:463
void SetVec3(const Math::vec3 &val)
set vec4 content
Definition variant.h:2577
int64_t i64
Definition variant.h:465
double GetDouble() const
get double content
Definition variant.h:2510
float f[4]
Definition variant.h:469
short GetShort() const
get short content
Definition variant.h:2384
Util::String * string
Definition variant.h:472
byte i8
Definition variant.h:460
const Util::Array< Math::vec4 > & GetVec4Array() const
get vec4 array content
Definition variant.h:2851
bool SetParseString(const Util::String &string)
set value from string, if type doesn't match, returns false
bool operator<=(const Variant &rhs) const
less equal operator
Definition variant.h:1904
bool operator>(const Variant &rhs) const
greater operator
Definition variant.h:1717
void * GetVoidPtr() const
get void pointer
uint64_t u64
Definition variant.h:466
const SizeT Size() const
get size of data
Definition variant.h:3350
void SetInt(int val)
set integer content
Definition variant.h:2404
const Util::Array< Math::vec2 > & GetVec2Array() const
get vec2 array content
Definition variant.h:2813
Util::Array< int > * intArray
Definition variant.h:477
void SetObject(Core::RefCounted *ptr)
set object pointer
Definition variant.h:2709
~Variant()
destructor
Definition variant.h:1097
void Copy(const Variant &rhs)
copy current content
Definition variant.h:619
Util::Array< Math::vec2 > * vec2Array
Definition variant.h:480
void SetUInt(uint val)
set unsigned integer content
Definition variant.h:2413
void SetTransform44(const Math::transform44 &val)
set transform44 content
Definition variant.h:2652
Util::Array< Math::vec3 > * float3Array
Definition variant.h:481
void SetMat4(const Math::mat4 &val)
set mat4 content
Definition variant.h:2633
ushort GetUShort() const
get short content
Definition variant.h:2394
Math::vec2 GetVec2() const
get vec2 content
Definition variant.h:2567
Util::Array< Util::String > * stringArray
Definition variant.h:484
const Util::Array< int > & GetIntArray() const
get int array content
Definition variant.h:2756
void SetGuidArray(const Util::Array< Util::Guid > &val)
set guid array content
Definition variant.h:2899
Util::String ToString() const
convert value to string
Definition variant.h:3229
uint u
Definition variant.h:464
void SetUShort(ushort val)
set ushort content
Definition variant.h:2375
void SetVec4(const Math::vec4 &val)
set vec4 content
Definition variant.h:2595
const Util::Array< bool > & GetBoolArray() const
get bool array content
Definition variant.h:2794
byte GetByte() const
get byte content
Definition variant.h:2356
void __cdecl n_error(const char *msg,...)
This function is called when a serious situation is encountered which requires abortion of the applic...
Definition debug.cc:138
#define n_assert(exp)
Definition debug.h:50
Implements a memory related functions.
A pinned array is an array which manages its own virtual memory.
Definition String.cs:6
A 4x4 single point precision float matrix.
Definition mat4.h:49
A quaternion is usually used to represent an orientation in 3D space.
Definition quat.h:30
float y
Definition quat.h:78
void storeu(scalar *ptr) const
write content to unaligned memory through the write cache
Definition quat.h:183
float z
Definition quat.h:78
float w
Definition quat.h:78
float x
Definition quat.h:78
A 2-component float vector class.
Definition vec2.h:21
scalar x
Definition vec2.h:86
scalar y
Definition vec2.h:87
A 3D vector.
Definition vec3.h:40
void storeu(scalar *ptr) const
write content to unaligned memory through the write cache
Definition vec3.h:196
A 4D vector.
Definition vec4.h:24
float y
Definition vec4.h:93
float z
Definition vec4.h:93
float w
Definition vec4.h:93
void storeu(scalar *ptr) const
write content to unaligned memory through the write cache
Definition vec4.h:201
float x
Definition vec4.h:93
Nebula's universal string class.
Definition string.h:50
static String FromVec3(const Math::vec3 &v)
construct a string from vec3
Definition string.h:985
static String FromUInt(uint i)
construct a string from a uint
Definition string.h:896
static String FromBool(bool b)
construct a string from a bool
Definition string.h:962
static String FromByte(byte i)
construct a string from a byte
Definition string.h:841
void AppendFloat(float val)
append float value
Definition string.h:1131
static String FromQuat(const Math::quat &q)
construct a string from quat
Definition string.h:1040
static String FromDouble(double f)
construct a string from a double
Definition string.h:951
void AppendBool(bool val)
append bool value
Definition string.h:1140
static String FromTransform44(const Math::transform44 &m)
construct a string from transform44
Definition string.h:1062
static String FromInt(int i)
construct a string from an int
Definition string.h:885
static String FromFloat(float f)
construct a string from a float
Definition string.h:940
static String FromVec4(const Math::vec4 &v)
construct a string from vec4
Definition string.h:996
void Append(const String &str)
append string
Definition string.h:615
static String FromMat4(const Math::mat4 &m)
construct a string from mat4
Definition string.h:1051
static String FromBlob(const Util::Blob &b)
create from blob
Definition string.cc:1185
static String FromShort(short i)
construct a string from a short
Definition string.h:863
static String FromUShort(ushort i)
construct a string from a ushort
Definition string.h:874
const char * AsCharPtr() const
return contents as character pointer
Definition string.h:540
void AppendInt(int val)
append int value
Definition string.h:1104
static String FromVec2(const Math::vec2 &v)
construct a string from vec2
Definition string.h:974
uint8_t uint8
Definition types.h:42
int SizeT
Definition types.h:49
unsigned int uint
Definition types.h:31
unsigned short ushort
Definition types.h:32
uint64_t uint64
Definition types.h:36
uint16_t uint16
Definition types.h:40
uint32_t uint32
Definition types.h:38
int IndexT
Definition types.h:48