430 template <
typename TYPE>
534 this->
object->Release();
648 this->
f[0] = rhs.
f[0];
657 this->
f[0] = rhs.
f[0];
658 this->
f[1] = rhs.
f[1];
661 this->
f[0] = rhs.
f[0];
662 this->
f[1] = rhs.
f[1];
663 this->
f[2] = rhs.
f[2];
666 this->
f[0] = rhs.
f[0];
667 this->
f[1] = rhs.
f[1];
668 this->
f[2] = rhs.
f[2];
669 this->
f[3] = rhs.
f[3];
672 this->
f[0] = rhs.
f[0];
673 this->
f[1] = rhs.
f[1];
674 this->
f[2] = rhs.
f[2];
675 this->
f[3] = rhs.
f[3];
693 this->
object = rhs.
object;
696 this->
object->AddRef();
733 n_error(
"Variant::Copy(): invalid type!");
928 this->
object->AddRef();
1450 this->
object->AddRef();
1652 if (rhs.
type == this->type)
1659 return (this->
i8 == rhs.
i8);
1661 return (this->
i16 == rhs.
i16);
1665 return (this->
i == rhs.
i);
1667 return (this->
u == rhs.
u);
1669 return (this->
i64 == rhs.
i64);
1671 return (this->
u64 == rhs.
u64);
1673 return (this->
b == rhs.
b);
1675 return (this->
f[0] == rhs.
f[0]);
1677 return (this->
d == rhs.
d);
1679 return ((*this->
string) == (*rhs.
string));
1681 return ((this->
f[0] == rhs.
f[0]) && (this->f[1] == rhs.
f[1]));
1683 return ((this->
f[0] == rhs.
f[0]) &&
1684 (this->f[1] == rhs.
f[1]) &&
1685 (this->f[2] == rhs.
f[2]) &&
1686 (this->f[3] == rhs.
f[3]));
1688 return ((this->
f[0] == rhs.
f[0]) &&
1689 (this->f[1] == rhs.
f[1]) &&
1690 (this->f[2] == rhs.
f[2]) &&
1691 (this->f[3] == rhs.
f[3]));
1693 return ((*this->
guid) == (*rhs.
guid));
1695 return ((*this->
blob) == (*rhs.
blob));
1697 return (this->
object == rhs.
object);
1701 return ((*this->
m) == (*rhs.
m));
1703 return ((*this->
t) == (*rhs.
t));
1705 n_error(
"Variant::operator==(): invalid variant type!");
1718 if (rhs.
type == this->type)
1725 return (this->
i8 > rhs.
i8);
1727 return (this->
i16 > rhs.
i16);
1731 return (this->
i > rhs.
i);
1733 return (this->
u > rhs.
u);
1735 return (this->
i64 > rhs.
i64);
1737 return (this->
u64 > rhs.
u64);
1739 return (this->
b > rhs.
b);
1741 return (this->
f[0] > rhs.
f[0]);
1743 return (this->
d > rhs.
d);
1745 return ((*this->
string) > (*rhs.
string));
1747 return ((this->
f[0] > rhs.
f[0]) && (this->f[1] > rhs.
f[1]));
1749 return ((this->
f[0] > rhs.
f[0]) &&
1750 (this->f[1] > rhs.
f[1]) &&
1751 (this->f[2] > rhs.
f[2]) &&
1752 (this->f[3] > rhs.
f[3]));
1754 return ((this->
f[0] > rhs.
f[0]) &&
1755 (this->f[1] > rhs.
f[1]) &&
1756 (this->f[2] > rhs.
f[2]) &&
1757 (this->f[3] > rhs.
f[3]));
1759 return ((*this->
guid) > (*rhs.
guid));
1761 return ((*this->
blob) > (*rhs.
blob));
1763 return (this->
object > rhs.
object);
1767 n_error(
"Variant::operator>(): invalid variant type!");
1780 if (rhs.
type == this->type)
1787 return (this->
i8 < rhs.
i8);
1789 return (this->
i16 < rhs.
i16);
1793 return (this->
i < rhs.
i);
1795 return (this->
u < rhs.
u);
1797 return (this->
i64 < rhs.
i64);
1799 return (this->
u64 < rhs.
u64);
1801 return (this->
b < rhs.
b);
1803 return (this->
f[0] < rhs.
f[0]);
1805 return (this->
d > rhs.
d);
1807 return ((*this->
string) < (*rhs.
string));
1809 return ((this->
f[0] < rhs.
f[0]) && (this->f[1] < rhs.
f[1]));
1811 return ((this->
f[0] < rhs.
f[0]) &&
1812 (this->f[1] < rhs.
f[1]) &&
1813 (this->f[2] < rhs.
f[2]) &&
1814 (this->f[3] < rhs.
f[3]));
1816 return ((this->
f[0] < rhs.
f[0]) &&
1817 (this->f[1] < rhs.
f[1]) &&
1818 (this->f[2] < rhs.
f[2]) &&
1819 (this->f[3] < rhs.
f[3]));
1821 return ((*this->
guid) < (*rhs.
guid));
1823 return ((*this->
blob) < (*rhs.
blob));
1825 return (this->
object < rhs.
object);
1829 n_error(
"Variant::operator<(): invalid variant type!");
1843 if (rhs.
type == this->type)
1850 return (this->
i8 >= rhs.
i8);
1852 return (this->
i16 >= rhs.
i16);
1856 return (this->
i >= rhs.
i);
1858 return (this->
u >= rhs.
u);
1860 return (this->
i64 >= rhs.
i64);
1862 return (this->
u64 >= rhs.
u64);
1864 return (this->
b >= rhs.
b);
1866 return (this->
f[0] >= rhs.
f[0]);
1868 return (this->
d >= rhs.
d);
1870 return ((*this->
string) >= (*rhs.
string));
1872 return ((this->
f[0] >= rhs.
f[0]) && (this->f[1] >= rhs.
f[1]));
1874 return ((this->
f[0] >= rhs.
f[0]) &&
1875 (this->f[1] >= rhs.
f[1]) &&
1876 (this->f[2] >= rhs.
f[2]) &&
1877 (this->f[3] >= rhs.
f[3]));
1879 return ((this->
f[0] >= rhs.
f[0]) &&
1880 (this->f[1] >= rhs.
f[1]) &&
1881 (this->f[2] >= rhs.
f[2]) &&
1882 (this->f[3] >= rhs.
f[3]));
1884 return ((*this->
guid) >= (*rhs.
guid));
1886 return ((*this->
blob) >= (*rhs.
blob));
1888 return (this->
object >= rhs.
object);
1892 n_error(
"Variant::operator>(): invalid variant type!");
1905 if (rhs.
type == this->type)
1912 return (this->
i8 <= rhs.
i8);
1914 return (this->
i16 <= rhs.
i16);
1918 return (this->
i <= rhs.
i);
1920 return (this->
u <= rhs.
u);
1922 return (this->
i64 <= rhs.
i64);
1924 return (this->
u64 <= rhs.
u64);
1926 return (this->
b <= rhs.
b);
1928 return (this->
f[0] <= rhs.
f[0]);
1930 return (this->
d >= rhs.
d);
1932 return ((*this->
string) <= (*rhs.
string));
1934 return ((this->
f[0] <= rhs.
f[0]) && (this->f[1] <= rhs.
f[1]));
1936 return ((this->
f[0] <= rhs.
f[0]) &&
1937 (this->f[1] <= rhs.
f[1]) &&
1938 (this->f[2] <= rhs.
f[2]) &&
1939 (this->f[3] <= rhs.
f[3]));
1941 return ((this->
f[0] <= rhs.
f[0]) &&
1942 (this->f[1] <= rhs.
f[1]) &&
1943 (this->f[2] <= rhs.
f[2]) &&
1944 (this->f[3] <= rhs.
f[3]));
1946 return ((*this->
guid) <= (*rhs.
guid));
1948 return ((*this->
blob) <= (*rhs.
blob));
1950 return (this->
object <= rhs.
object);
1954 n_error(
"Variant::operator<(): invalid variant type!");
1967 return !(*
this == rhs);
1977 return (this->
i8 == rhs);
1987 return (this->
i16 == rhs);
1997 return (this->
ui16 == rhs);
2007 return (this->
i == rhs);
2017 return (this->
u == rhs);
2027 return (this->
i64 == rhs);
2037 return (this->
u64 == rhs);
2047 return (this->
f[0] == rhs);
2057 return (this->
d == rhs);
2067 return (this->
b == rhs);
2077 return ((*this->
string) == rhs);
2097 return (this->
f[0] == rhs.
x && this->f[1] == rhs.
y);
2107 return ((this->
f[0] == rhs.
x) &&
2108 (this->f[1] == rhs.
y) &&
2109 (this->f[2] == rhs.
z) &&
2110 (this->f[3] == rhs.
w));
2120 return ((this->
f[0] == rhs.
x) &&
2121 (this->f[1] == rhs.
y) &&
2122 (this->f[2] == rhs.
z) &&
2123 (this->f[3] == rhs.
w));
2133 return (*this->
guid) == rhs;
2143 return this->
object == ptr;
2163 return (this->
i8 != rhs);
2173 return (this->
i16 != rhs);
2183 return (this->
ui16 != rhs);
2193 return (this->
i != rhs);
2203 return (this->
u != rhs);
2213 return (this->
i64 != rhs);
2223 return (this->
u64 != rhs);
2233 return (this->
f[0] != rhs);
2243 return (this->
d != rhs);
2253 return (this->
b != rhs);
2263 return (*this->
string) != rhs;
2283 return (this->
f[0] != rhs.
x || this->f[1] != rhs.
y);
2293 return ((this->
f[0] != rhs.
x) ||
2294 (this->f[1] != rhs.
y) ||
2295 (this->f[2] != rhs.
z) ||
2296 (this->f[3] != rhs.
w));
2306 return ((this->
f[0] != rhs.
x) ||
2307 (this->f[1] != rhs.
y) ||
2308 (this->f[2] != rhs.
z) ||
2309 (this->f[3] != rhs.
w));
2319 return (*this->
guid) != rhs;
2329 return (this->
object == ptr);
2339 return (this->
voidPtr == ptr);
2606 return Math::vec4(this->
f[0], this->
f[1], this->
f[2], this->
f[3]);
2625 return Math::quat(this->
f[0], this->
f[1], this->
f[2], this->
f[3]);
2682 return *(this->
guid);
2701 return *(this->
blob);
2739 return this->voidPtr;
2935template <
typename TYPE>
2939 static_assert(
true,
"Get method for TYPE is not implemented!");
3250 case Guid: { retval = this->
GetGuid().AsString();
break; }
3256 n_error(
"Variant::ToString(): invalid type enum '%d'", this->
type);
3270 bool retval =
false;
3274 case UInt: {
if(
string.IsValidInt()) { this->SetUInt(
string.AsInt()); retval =
true; }
break; };
3275 case Float: {
if(
string.IsValidFloat()) { this->SetFloat(
string.AsFloat()); retval =
true; }
break; }
3276 case Bool: {
if(
string.IsValidBool()) { this->SetBool(
string.AsBool()); retval =
true; }
break; }
3277 case Vec2: {
if(
string.IsValidVec2()) { this->SetVec2(
string.AsVec2()); retval =
true; }
break; }
3278 case Vec4: {
if(
string.IsValidVec4()) { this->SetVec4(
string.AsVec4()); retval =
true; }
break; }
3279 case String: { this->SetString(
string); retval =
true;
break; }
3280 case Mat4: {
if(
string.IsValidMat4()) { this->SetMat4(
string.AsMat4()); retval =
true; }
break; }
3281 case Transform44: {
if (
string.IsValidTransform44()) { this->SetTransform44(
string.AsTransform44()); retval =
true; }
break; }
3288 for (i = 0; i < tokens.
Size(); i++)
3290 if (tokens[i].IsValidInt())
3292 result.
Append(tokens[i].AsInt());
3295 this->SetIntArray(result);
3304 for (i = 0; i < tokens.
Size(); i++)
3306 if (tokens[i].IsValidFloat())
3308 result.
Append(tokens[i].AsFloat());
3311 this->SetFloatArray(result);
3320 for (i = 0; i < tokens.
Size(); i++)
3322 if (tokens[i].IsValidBool())
3324 result.
Append(tokens[i].AsBool());
3327 this->SetBoolArray(result);
3334 this->SetStringArray(tokens);
3353 case Void:
return 0;
3361 case Float:
return sizeof(float);
3362 case Double:
return sizeof(double);
3363 case Bool:
return sizeof(bool);
3364 case Vec2:
return sizeof(float) * 2;
3365 case Vec4:
return sizeof(float) * 4;
3373 case VoidPtr:
return sizeof(
void*);
3384 n_error(
"Variant::Size(): invalid type enum '%d'!", this->
type);
3432 n_error(
"Variant::AsVoidPtr(): invalid type enum '%d'!", this->
type);
3445 if (
string.IsValidInt()) val.
SetInt(
string.AsInt());
3446 else if (
string.IsValidFloat()) val.
SetFloat(
string.AsFloat());
3447 else if (
string.IsValidVec2()) val.
SetVec2(
string.AsVec2());
3448 else if (
string.IsValidVec4()) val.
SetVec4(
string.AsVec4());
3449 else if (
string.IsValidBool()) val.
SetBool(
string.AsBool());
3450 else if (
string.IsValidMat4()) val.
SetMat4(
string.AsMat4());
3463 case Void:
return "void";
3464 case Byte:
return "byte";
3465 case Short:
return "short";
3466 case UShort:
return "ushort";
3467 case Int:
return "int";
3468 case UInt:
return "uint";
3469 case Int64:
return "int64";
3470 case UInt64:
return "uint64";
3471 case Float:
return "float";
3472 case Double:
return "double";
3473 case Bool:
return "bool";
3474 case Vec2:
return "vec2";
3475 case Vec4:
return "vec4";
3477 case String:
return "string";
3478 case Mat4:
return "mat4";
3480 case Blob:
return "blob";
3481 case Guid:
return "guid";
3482 case Object:
return "object";
3483 case VoidPtr:
return "voidptr";
3494 n_error(
"Variant::TypeToString(): invalid type enum '%d'!",
t);
3505 if (
"void" == str)
return Void;
3506 else if (
"byte" == str)
return Byte;
3507 else if (
"short" == str)
return Short;
3508 else if (
"ushort" == str)
return UShort;
3509 else if (
"int" == str)
return Int;
3510 else if (
"uint" == str)
return UInt;
3511 else if (
"int64" == str)
return Int64;
3512 else if (
"uint64" == str)
return UInt64;
3513 else if (
"float" == str)
return Float;
3514 else if (
"double" == str)
return Double;
3515 else if (
"bool" == str)
return Bool;
3516 else if (
"vec2" == str)
return Vec2;
3517 else if (
"vec4" == str)
return Vec4;
3518 else if (
"color" == str)
return Vec4;
3519 else if (
"quaternion" == str)
return Quaternion;
3520 else if (
"string" == str)
return String;
3521 else if (
"mat4" == str)
return Mat4;
3522 else if (
"transform44" == str)
return Transform44;
3523 else if (
"blob" == str)
return Blob;
3524 else if (
"guid" == str)
return Guid;
3525 else if (
"object" == str)
return Object;
3526 else if (
"voidptr" == str)
return VoidPtr;
3527 else if (
"intarray" == str)
return IntArray;
3528 else if (
"floatarray" == str)
return FloatArray;
3529 else if (
"boolarray" == str)
return BoolArray;
3530 else if (
"vec2array" == str)
return Vec2Array;
3531 else if (
"vec4array" == str)
return Vec4Array;
3532 else if (
"mat4array" == str)
return Mat4Array;
3533 else if (
"stringarray" == str)
return StringArray;
3534 else if (
"guidarray" == str)
return GuidArray;
3535 else if (
"blobarray" == str)
return BlobArray;
3538 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:1332
const SizeT Size() const
get number of elements in array
Definition array.h:878
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:30
void SetDouble(double val)
set double content
Definition variant.h:2500
Util::Array< Math::mat4 > * mat4Array
Definition variant.h:482
const Util::Array< Util::String > & GetStringArray() const
get string array content
Definition variant.h:2888
void SetBlob(const Util::Blob &val)
set blob
Definition variant.h:2689
int64_t GetInt64() const
get integer content
Definition variant.h:2451
Core::RefCounted * object
Definition variant.h:475
const Math::mat4 & GetMat4() const
get mat4 content
Definition variant.h:2641
Math::quat GetQuat() const
get quaternion content
Definition variant.h:2622
Type
variant types
Definition variant.h:34
@ Short
Definition variant.h:37
@ BlobArray
Definition variant.h:65
@ UInt64
Definition variant.h:42
@ Int
Definition variant.h:39
@ Vec4Array
Definition variant.h:62
@ Quaternion
Definition variant.h:49
@ Blob
Definition variant.h:53
@ Vec3Array
Definition variant.h:61
@ Transform44
Definition variant.h:52
@ Float
Definition variant.h:43
@ Bool
Definition variant.h:45
@ FloatArray
Definition variant.h:58
@ Vec2
Definition variant.h:46
@ GuidArray
Definition variant.h:66
@ String
Definition variant.h:50
@ Object
Definition variant.h:55
@ StringArray
Definition variant.h:63
@ Void
Definition variant.h:35
@ NumTypes
Definition variant.h:67
@ UInt
Definition variant.h:40
@ IntArray
Definition variant.h:57
@ Mat4Array
Definition variant.h:64
@ Vec3
Definition variant.h:47
@ Guid
Definition variant.h:54
@ Double
Definition variant.h:44
@ Mat4
Definition variant.h:51
@ VoidPtr
Definition variant.h:56
@ Vec2Array
Definition variant.h:60
@ Int64
Definition variant.h:41
@ Byte
Definition variant.h:36
@ Vec4
Definition variant.h:48
@ UShort
Definition variant.h:38
@ BoolArray
Definition variant.h:59
const Util::Array< Math::mat4 > & GetMat4Array() const
get mat4 array content
Definition variant.h:2869
Math::vec4 GetVec4() const
get vec4 content
Definition variant.h:2603
int GetInt() const
get integer content
Definition variant.h:2421
double d
Definition variant.h:467
const Util::String & GetString() const
get string content
Definition variant.h:2547
bool operator>=(const Variant &rhs) const
greater equal operator
Definition variant.h:1841
void * voidPtr
Definition variant.h:474
bool b
Definition variant.h:466
void SetFloat(float val)
set float content
Definition variant.h:2481
Util::Guid * guid
Definition variant.h:472
uint GetUInt() const
get unsigned integer content
Definition variant.h:2431
void SetBool(bool val)
set bool content
Definition variant.h:2519
Math::transform44 * t
Definition variant.h:470
bool GetBool() const
get bool content
Definition variant.h:2528
void Clear()
clear content, resets type to void
Definition variant.h:609
static Variant FromString(const Util::String &string)
create from string
Definition variant.h:3442
Util::Blob * blob
Definition variant.h:473
void SetShort(short val)
set short content
Definition variant.h:2365
bool operator!=(const Variant &rhs) const
inequality operator
Definition variant.h:1965
void SetBoolArray(const Util::Array< bool > &val)
set bool array content
Definition variant.h:2784
void operator=(const Variant &rhs)
assignment operator
Definition variant.h:1180
const Util::Array< Math::vec3 > & GetVec3Array() const
get vec4 array content
Definition variant.h:2831
void SetByte(byte val)
set byte content
Definition variant.h:2346
Util::Array< bool > * boolArray
Definition variant.h:478
ushort ui16
Definition variant.h:461
void SetBlobArray(const Util::Array< Util::Blob > &val)
set blob array content
Definition variant.h:2917
void SetVec3Array(const Util::Array< Math::vec3 > &val)
set vec4 array content
Definition variant.h:2822
Variant()
default constructor
Definition variant.h:493
Util::Array< Util::Guid > * guidArray
Definition variant.h:484
Type GetType() const
get type
Definition variant.h:1171
void SetGuid(const Util::Guid &val)
set guid content
Definition variant.h:2670
void SetString(const Util::String &val)
set string content
Definition variant.h:2538
Util::Array< Util::Blob > * blobArray
Definition variant.h:485
const Util::Array< float > & GetFloatArray() const
get float array content
Definition variant.h:2774
void SetFloatArray(const Util::Array< float > &val)
set float array content
Definition variant.h:2765
void SetType(Type t)
set type of attribute
Definition variant.h:1105
void SetInt64(int64_t val)
set integer content
Definition variant.h:2441
TYPE Get() const
Templated get method.
Definition variant.h:2937
void SetMat4Array(const Util::Array< Math::mat4 > &val)
set mat4 array content
Definition variant.h:2860
void SetVec4Array(const Util::Array< Math::vec4 > &val)
set vec4 array content
Definition variant.h:2841
const Util::Array< Util::Blob > & GetBlobArray() const
get blob array content
Definition variant.h:2926
bool operator==(const Variant &rhs) const
equality operator
Definition variant.h:1650
const Util::Guid & GetGuid() const
get guid content
Definition variant.h:2679
void SetVec2(const Math::vec2 &val)
set vec2 content
Definition variant.h:2557
float GetFloat() const
get float content
Definition variant.h:2490
void SetUInt64(uint64_t val)
set unsigned integer content
Definition variant.h:2461
void SetVoidPtr(void *ptr)
set opaque void pointer
uint64_t GetUInt64() const
get unsigned integer content
Definition variant.h:2471
void SetVec2Array(const Util::Array< Math::vec2 > &val)
set vec2 array content
Definition variant.h:2803
void SetStringArray(const Util::Array< Util::String > &val)
set string array content
Definition variant.h:2879
const Util::Array< Util::Guid > & GetGuidArray() const
get guid array content
Definition variant.h:2907
Math::vec3 GetVec3() const
get vec4 content
Definition variant.h:2585
Util::Array< Math::vec4 > * vec4Array
Definition variant.h:481
const void * AsVoidPtr() const
get pointer to data
Definition variant.h:3394
static Type StringToType(const Util::String &str)
convert string to type
Definition variant.h:3503
void Delete()
delete current content
Definition variant.h:504
void SetIntArray(const Util::Array< int > &val)
set int array content
Definition variant.h:2746
Type type
Definition variant.h:456
const Math::transform44 & GetTransform44() const
get transform44 content
Definition variant.h:2660
Core::RefCounted * GetObject() const
get object pointer
Definition variant.h:2717
void SetQuat(const Math::quat &val)
set quaternion content
Definition variant.h:2613
Math::mat4 * m
Definition variant.h:469
bool operator<(const Variant &rhs) const
less operator
Definition variant.h:1778
const Util::Blob & GetBlob() const
get blob
Definition variant.h:2698
static Util::String TypeToString(Type t)
convert type to string
Definition variant.h:3459
short i16
Definition variant.h:460
Util::Array< float > * floatArray
Definition variant.h:477
int i
Definition variant.h:462
void SetVec3(const Math::vec3 &val)
set vec4 content
Definition variant.h:2576
int64_t i64
Definition variant.h:464
double GetDouble() const
get double content
Definition variant.h:2509
float f[4]
Definition variant.h:468
short GetShort() const
get short content
Definition variant.h:2383
Util::String * string
Definition variant.h:471
byte i8
Definition variant.h:459
const Util::Array< Math::vec4 > & GetVec4Array() const
get vec4 array content
Definition variant.h:2850
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:1903
bool operator>(const Variant &rhs) const
greater operator
Definition variant.h:1716
void * GetVoidPtr() const
get void pointer
uint64_t u64
Definition variant.h:465
const SizeT Size() const
get size of data
Definition variant.h:3349
void SetInt(int val)
set integer content
Definition variant.h:2403
const Util::Array< Math::vec2 > & GetVec2Array() const
get vec2 array content
Definition variant.h:2812
Util::Array< int > * intArray
Definition variant.h:476
void SetObject(Core::RefCounted *ptr)
set object pointer
Definition variant.h:2708
~Variant()
destructor
Definition variant.h:1096
void Copy(const Variant &rhs)
copy current content
Definition variant.h:618
Util::Array< Math::vec2 > * vec2Array
Definition variant.h:479
void SetUInt(uint val)
set unsigned integer content
Definition variant.h:2412
void SetTransform44(const Math::transform44 &val)
set transform44 content
Definition variant.h:2651
Util::Array< Math::vec3 > * float3Array
Definition variant.h:480
void SetMat4(const Math::mat4 &val)
set mat4 content
Definition variant.h:2632
ushort GetUShort() const
get short content
Definition variant.h:2393
Math::vec2 GetVec2() const
get vec2 content
Definition variant.h:2566
Util::Array< Util::String > * stringArray
Definition variant.h:483
const Util::Array< int > & GetIntArray() const
get int array content
Definition variant.h:2755
void SetGuidArray(const Util::Array< Util::Guid > &val)
set guid array content
Definition variant.h:2898
Util::String ToString() const
convert value to string
Definition variant.h:3228
uint u
Definition variant.h:463
void SetUShort(ushort val)
set ushort content
Definition variant.h:2374
void SetVec4(const Math::vec4 &val)
set vec4 content
Definition variant.h:2594
const Util::Array< bool > & GetBoolArray() const
get bool array content
Definition variant.h:2793
byte GetByte() const
get byte content
Definition variant.h:2355
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:47
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:39
void storeu(scalar *ptr) const
write content to unaligned memory through the write cache
Definition vec3.h:195
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