|
@@ -33,50 +33,50 @@ unsigned CountElements(const char* buffer, char separator)
|
|
|
{
|
|
{
|
|
|
if (!buffer)
|
|
if (!buffer)
|
|
|
return 0;
|
|
return 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
const char* endPos = buffer + String::CStringLength(buffer);
|
|
const char* endPos = buffer + String::CStringLength(buffer);
|
|
|
const char* pos = buffer;
|
|
const char* pos = buffer;
|
|
|
unsigned ret = 0;
|
|
unsigned ret = 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
while (pos < endPos)
|
|
while (pos < endPos)
|
|
|
{
|
|
{
|
|
|
if (*pos != separator)
|
|
if (*pos != separator)
|
|
|
break;
|
|
break;
|
|
|
++pos;
|
|
++pos;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
while (pos < endPos)
|
|
while (pos < endPos)
|
|
|
{
|
|
{
|
|
|
const char* start = pos;
|
|
const char* start = pos;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
while (start < endPos)
|
|
while (start < endPos)
|
|
|
{
|
|
{
|
|
|
if (*start == separator)
|
|
if (*start == separator)
|
|
|
break;
|
|
break;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
++start;
|
|
++start;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
if (start == endPos)
|
|
if (start == endPos)
|
|
|
{
|
|
{
|
|
|
++ret;
|
|
++ret;
|
|
|
break;
|
|
break;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
const char* end = start;
|
|
const char* end = start;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
while (end < endPos)
|
|
while (end < endPos)
|
|
|
{
|
|
{
|
|
|
if (*end != separator)
|
|
if (*end != separator)
|
|
|
break;
|
|
break;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
++end;
|
|
++end;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
++ret;
|
|
++ret;
|
|
|
pos = end;
|
|
pos = end;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -88,7 +88,7 @@ bool ToBool(const String& source)
|
|
|
bool ToBool(const char* source)
|
|
bool ToBool(const char* source)
|
|
|
{
|
|
{
|
|
|
unsigned length = String::CStringLength(source);
|
|
unsigned length = String::CStringLength(source);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
for (unsigned i = 0; i < length; ++i)
|
|
for (unsigned i = 0; i < length; ++i)
|
|
|
{
|
|
{
|
|
|
char c = tolower(source[i]);
|
|
char c = tolower(source[i]);
|
|
@@ -97,7 +97,7 @@ bool ToBool(const char* source)
|
|
|
else if (c != ' ' && c != '\t')
|
|
else if (c != ' ' && c != '\t')
|
|
|
break;
|
|
break;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return false;
|
|
return false;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -110,7 +110,7 @@ int ToInt(const char* source)
|
|
|
{
|
|
{
|
|
|
if (!source)
|
|
if (!source)
|
|
|
return 0;
|
|
return 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
// Explicitly ask for base 10 to prevent source starts with '0' or '0x' from being converted to base 8 or base 16, respectively
|
|
// Explicitly ask for base 10 to prevent source starts with '0' or '0x' from being converted to base 8 or base 16, respectively
|
|
|
return strtol(source, 0, 10);
|
|
return strtol(source, 0, 10);
|
|
|
}
|
|
}
|
|
@@ -124,7 +124,7 @@ unsigned ToUInt(const char* source)
|
|
|
{
|
|
{
|
|
|
if (!source)
|
|
if (!source)
|
|
|
return 0;
|
|
return 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return strtoul(source, 0, 10);
|
|
return strtoul(source, 0, 10);
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -137,7 +137,7 @@ float ToFloat(const char* source)
|
|
|
{
|
|
{
|
|
|
if (!source)
|
|
if (!source)
|
|
|
return 0;
|
|
return 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return (float)strtod(source, 0);
|
|
return (float)strtod(source, 0);
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -149,18 +149,18 @@ Color ToColor(const String& source)
|
|
|
Color ToColor(const char* source)
|
|
Color ToColor(const char* source)
|
|
|
{
|
|
{
|
|
|
Color ret;
|
|
Color ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 3)
|
|
if (elements < 3)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.r_ = (float)strtod(ptr, &ptr);
|
|
ret.r_ = (float)strtod(ptr, &ptr);
|
|
|
ret.g_ = (float)strtod(ptr, &ptr);
|
|
ret.g_ = (float)strtod(ptr, &ptr);
|
|
|
ret.b_ = (float)strtod(ptr, &ptr);
|
|
ret.b_ = (float)strtod(ptr, &ptr);
|
|
|
if (elements > 3)
|
|
if (elements > 3)
|
|
|
ret.a_ = (float)strtod(ptr, &ptr);
|
|
ret.a_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -172,17 +172,17 @@ IntRect ToIntRect(const String& source)
|
|
|
IntRect ToIntRect(const char* source)
|
|
IntRect ToIntRect(const char* source)
|
|
|
{
|
|
{
|
|
|
IntRect ret(IntRect::ZERO);
|
|
IntRect ret(IntRect::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 4)
|
|
if (elements < 4)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
- ret.left_ = strtol(ptr, &ptr, 10);
|
|
|
|
|
- ret.top_ = strtol(ptr, &ptr, 10);
|
|
|
|
|
- ret.right_ = strtol(ptr, &ptr, 10);
|
|
|
|
|
- ret.bottom_ = strtol(ptr, &ptr, 10);
|
|
|
|
|
-
|
|
|
|
|
|
|
+ ret.left_ = (int)strtol(ptr, &ptr, 10);
|
|
|
|
|
+ ret.top_ = (int)strtol(ptr, &ptr, 10);
|
|
|
|
|
+ ret.right_ = (int)strtol(ptr, &ptr, 10);
|
|
|
|
|
+ ret.bottom_ = (int)strtol(ptr, &ptr, 10);
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -194,15 +194,15 @@ IntVector2 ToIntVector2(const String& source)
|
|
|
IntVector2 ToIntVector2(const char* source)
|
|
IntVector2 ToIntVector2(const char* source)
|
|
|
{
|
|
{
|
|
|
IntVector2 ret(IntVector2::ZERO);
|
|
IntVector2 ret(IntVector2::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 2)
|
|
if (elements < 2)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
- ret.x_ = strtol(ptr, &ptr, 10);
|
|
|
|
|
- ret.y_ = strtol(ptr, &ptr, 10);
|
|
|
|
|
-
|
|
|
|
|
|
|
+ ret.x_ = (int)strtol(ptr, &ptr, 10);
|
|
|
|
|
+ ret.y_ = (int)strtol(ptr, &ptr, 10);
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -214,17 +214,17 @@ Rect ToRect(const String& source)
|
|
|
Rect ToRect(const char* source)
|
|
Rect ToRect(const char* source)
|
|
|
{
|
|
{
|
|
|
Rect ret(Rect::ZERO);
|
|
Rect ret(Rect::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 4)
|
|
if (elements < 4)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.min_.x_ = (float)strtod(ptr, &ptr);
|
|
ret.min_.x_ = (float)strtod(ptr, &ptr);
|
|
|
ret.min_.y_ = (float)strtod(ptr, &ptr);
|
|
ret.min_.y_ = (float)strtod(ptr, &ptr);
|
|
|
ret.max_.x_ = (float)strtod(ptr, &ptr);
|
|
ret.max_.x_ = (float)strtod(ptr, &ptr);
|
|
|
ret.max_.y_ = (float)strtod(ptr, &ptr);
|
|
ret.max_.y_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -237,7 +237,7 @@ Quaternion ToQuaternion(const char* source)
|
|
|
{
|
|
{
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
if (elements < 3)
|
|
if (elements < 3)
|
|
|
return Quaternion::IDENTITY;
|
|
return Quaternion::IDENTITY;
|
|
|
else if (elements < 4)
|
|
else if (elements < 4)
|
|
@@ -247,7 +247,7 @@ Quaternion ToQuaternion(const char* source)
|
|
|
x = (float)strtod(ptr, &ptr);
|
|
x = (float)strtod(ptr, &ptr);
|
|
|
y = (float)strtod(ptr, &ptr);
|
|
y = (float)strtod(ptr, &ptr);
|
|
|
z = (float)strtod(ptr, &ptr);
|
|
z = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return Quaternion(x, y, z);
|
|
return Quaternion(x, y, z);
|
|
|
}
|
|
}
|
|
|
else
|
|
else
|
|
@@ -258,7 +258,7 @@ Quaternion ToQuaternion(const char* source)
|
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
}
|
|
}
|
|
@@ -271,15 +271,15 @@ Vector2 ToVector2(const String& source)
|
|
|
Vector2 ToVector2(const char* source)
|
|
Vector2 ToVector2(const char* source)
|
|
|
{
|
|
{
|
|
|
Vector2 ret(Vector2::ZERO);
|
|
Vector2 ret(Vector2::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 2)
|
|
if (elements < 2)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -291,16 +291,16 @@ Vector3 ToVector3(const String& source)
|
|
|
Vector3 ToVector3(const char* source)
|
|
Vector3 ToVector3(const char* source)
|
|
|
{
|
|
{
|
|
|
Vector3 ret(Vector3::ZERO);
|
|
Vector3 ret(Vector3::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 3)
|
|
if (elements < 3)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -312,20 +312,20 @@ Vector4 ToVector4(const String& source, bool allowMissingCoords)
|
|
|
Vector4 ToVector4(const char* source, bool allowMissingCoords)
|
|
Vector4 ToVector4(const char* source, bool allowMissingCoords)
|
|
|
{
|
|
{
|
|
|
Vector4 ret(Vector4::ZERO);
|
|
Vector4 ret(Vector4::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
if (!allowMissingCoords)
|
|
if (!allowMissingCoords)
|
|
|
{
|
|
{
|
|
|
if (elements < 4)
|
|
if (elements < 4)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
ret.x_ = (float)strtod(ptr, &ptr);
|
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
ret.y_ = (float)strtod(ptr, &ptr);
|
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
|
ret.w_ = (float)strtod(ptr, &ptr);
|
|
ret.w_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
else
|
|
else
|
|
@@ -338,7 +338,7 @@ Vector4 ToVector4(const char* source, bool allowMissingCoords)
|
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
ret.z_ = (float)strtod(ptr, &ptr);
|
|
|
if (elements > 3)
|
|
if (elements > 3)
|
|
|
ret.w_ = (float)strtod(ptr, &ptr);
|
|
ret.w_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
}
|
|
}
|
|
@@ -352,25 +352,25 @@ Variant ToVectorVariant(const char* source)
|
|
|
{
|
|
{
|
|
|
Variant ret;
|
|
Variant ret;
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
switch (elements)
|
|
switch (elements)
|
|
|
{
|
|
{
|
|
|
case 1:
|
|
case 1:
|
|
|
ret.FromString(VAR_FLOAT, source);
|
|
ret.FromString(VAR_FLOAT, source);
|
|
|
break;
|
|
break;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
case 2:
|
|
case 2:
|
|
|
ret.FromString(VAR_VECTOR2, source);
|
|
ret.FromString(VAR_VECTOR2, source);
|
|
|
break;
|
|
break;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
case 3:
|
|
case 3:
|
|
|
ret.FromString(VAR_VECTOR3, source);
|
|
ret.FromString(VAR_VECTOR3, source);
|
|
|
break;
|
|
break;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
case 4:
|
|
case 4:
|
|
|
ret.FromString(VAR_VECTOR4, source);
|
|
ret.FromString(VAR_VECTOR4, source);
|
|
|
break;
|
|
break;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
case 9:
|
|
case 9:
|
|
|
ret.FromString(VAR_MATRIX3, source);
|
|
ret.FromString(VAR_MATRIX3, source);
|
|
|
break;
|
|
break;
|
|
@@ -383,7 +383,7 @@ Variant ToVectorVariant(const char* source)
|
|
|
ret.FromString(VAR_MATRIX4, source);
|
|
ret.FromString(VAR_MATRIX4, source);
|
|
|
break;
|
|
break;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -395,11 +395,11 @@ Matrix3 ToMatrix3(const String& source)
|
|
|
Matrix3 ToMatrix3(const char* source)
|
|
Matrix3 ToMatrix3(const char* source)
|
|
|
{
|
|
{
|
|
|
Matrix3 ret(Matrix3::ZERO);
|
|
Matrix3 ret(Matrix3::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 9)
|
|
if (elements < 9)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.m00_ = (float)strtod(ptr, &ptr);
|
|
ret.m00_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m01_ = (float)strtod(ptr, &ptr);
|
|
ret.m01_ = (float)strtod(ptr, &ptr);
|
|
@@ -410,7 +410,7 @@ Matrix3 ToMatrix3(const char* source)
|
|
|
ret.m20_ = (float)strtod(ptr, &ptr);
|
|
ret.m20_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m21_ = (float)strtod(ptr, &ptr);
|
|
ret.m21_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m22_ = (float)strtod(ptr, &ptr);
|
|
ret.m22_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -422,11 +422,11 @@ Matrix3x4 ToMatrix3x4(const String& source)
|
|
|
Matrix3x4 ToMatrix3x4(const char* source)
|
|
Matrix3x4 ToMatrix3x4(const char* source)
|
|
|
{
|
|
{
|
|
|
Matrix3x4 ret(Matrix3x4::ZERO);
|
|
Matrix3x4 ret(Matrix3x4::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 12)
|
|
if (elements < 12)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.m00_ = (float)strtod(ptr, &ptr);
|
|
ret.m00_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m01_ = (float)strtod(ptr, &ptr);
|
|
ret.m01_ = (float)strtod(ptr, &ptr);
|
|
@@ -440,7 +440,7 @@ Matrix3x4 ToMatrix3x4(const char* source)
|
|
|
ret.m21_ = (float)strtod(ptr, &ptr);
|
|
ret.m21_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m22_ = (float)strtod(ptr, &ptr);
|
|
ret.m22_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m23_ = (float)strtod(ptr, &ptr);
|
|
ret.m23_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -452,11 +452,11 @@ Matrix4 ToMatrix4(const String& source)
|
|
|
Matrix4 ToMatrix4(const char* source)
|
|
Matrix4 ToMatrix4(const char* source)
|
|
|
{
|
|
{
|
|
|
Matrix4 ret(Matrix4::ZERO);
|
|
Matrix4 ret(Matrix4::ZERO);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned elements = CountElements(source, ' ');
|
|
unsigned elements = CountElements(source, ' ');
|
|
|
if (elements < 16)
|
|
if (elements < 16)
|
|
|
return ret;
|
|
return ret;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
char* ptr = (char*)source;
|
|
char* ptr = (char*)source;
|
|
|
ret.m00_ = (float)strtod(ptr, &ptr);
|
|
ret.m00_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m01_ = (float)strtod(ptr, &ptr);
|
|
ret.m01_ = (float)strtod(ptr, &ptr);
|
|
@@ -474,7 +474,7 @@ Matrix4 ToMatrix4(const char* source)
|
|
|
ret.m31_ = (float)strtod(ptr, &ptr);
|
|
ret.m31_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m32_ = (float)strtod(ptr, &ptr);
|
|
ret.m32_ = (float)strtod(ptr, &ptr);
|
|
|
ret.m33_ = (float)strtod(ptr, &ptr);
|
|
ret.m33_ = (float)strtod(ptr, &ptr);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return ret;
|
|
return ret;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
@@ -500,7 +500,7 @@ void BufferToString(String& dest, const void* data, unsigned size)
|
|
|
// Room for separator
|
|
// Room for separator
|
|
|
if (i)
|
|
if (i)
|
|
|
++length;
|
|
++length;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
// Room for the value
|
|
// Room for the value
|
|
|
if (bytes[i] < 10)
|
|
if (bytes[i] < 10)
|
|
|
++length;
|
|
++length;
|
|
@@ -509,16 +509,16 @@ void BufferToString(String& dest, const void* data, unsigned size)
|
|
|
else
|
|
else
|
|
|
length += 3;
|
|
length += 3;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
dest.Resize(length);
|
|
dest.Resize(length);
|
|
|
unsigned index = 0;
|
|
unsigned index = 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
// Convert values
|
|
// Convert values
|
|
|
for (unsigned i = 0; i < size; ++i)
|
|
for (unsigned i = 0; i < size; ++i)
|
|
|
{
|
|
{
|
|
|
if (i)
|
|
if (i)
|
|
|
dest[index++] = ' ';
|
|
dest[index++] = ' ';
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
if (bytes[i] < 10)
|
|
if (bytes[i] < 10)
|
|
|
{
|
|
{
|
|
|
dest[index++] = '0' + bytes[i];
|
|
dest[index++] = '0' + bytes[i];
|
|
@@ -549,14 +549,14 @@ void StringToBuffer(PODVector<unsigned char>& dest, const char* source)
|
|
|
dest.Clear();
|
|
dest.Clear();
|
|
|
return;
|
|
return;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
unsigned size = CountElements(source, ' ');
|
|
unsigned size = CountElements(source, ' ');
|
|
|
dest.Resize(size);
|
|
dest.Resize(size);
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
bool inSpace = true;
|
|
bool inSpace = true;
|
|
|
unsigned index = 0;
|
|
unsigned index = 0;
|
|
|
unsigned value = 0;
|
|
unsigned value = 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
// Parse values
|
|
// Parse values
|
|
|
const char* ptr = source;
|
|
const char* ptr = source;
|
|
|
while (*ptr)
|
|
while (*ptr)
|
|
@@ -576,10 +576,10 @@ void StringToBuffer(PODVector<unsigned char>& dest, const char* source)
|
|
|
dest[index++] = value;
|
|
dest[index++] = value;
|
|
|
inSpace = true;
|
|
inSpace = true;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
++ptr;
|
|
++ptr;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
// Write the final value
|
|
// Write the final value
|
|
|
if (!inSpace && index < size)
|
|
if (!inSpace && index < size)
|
|
|
dest[index] = value;
|
|
dest[index] = value;
|
|
@@ -593,28 +593,28 @@ unsigned GetStringListIndex(const String& value, const String* strings, unsigned
|
|
|
unsigned GetStringListIndex(const char* value, const String* strings, unsigned defaultIndex, bool caseSensitive)
|
|
unsigned GetStringListIndex(const char* value, const String* strings, unsigned defaultIndex, bool caseSensitive)
|
|
|
{
|
|
{
|
|
|
unsigned i = 0;
|
|
unsigned i = 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
while (!strings[i].Empty())
|
|
while (!strings[i].Empty())
|
|
|
{
|
|
{
|
|
|
if (!strings[i].Compare(value, caseSensitive))
|
|
if (!strings[i].Compare(value, caseSensitive))
|
|
|
return i;
|
|
return i;
|
|
|
++i;
|
|
++i;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return defaultIndex;
|
|
return defaultIndex;
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
unsigned GetStringListIndex(const char* value, const char** strings, unsigned defaultIndex, bool caseSensitive)
|
|
unsigned GetStringListIndex(const char* value, const char** strings, unsigned defaultIndex, bool caseSensitive)
|
|
|
{
|
|
{
|
|
|
unsigned i = 0;
|
|
unsigned i = 0;
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
while (strings[i])
|
|
while (strings[i])
|
|
|
{
|
|
{
|
|
|
if (!String::Compare(value, strings[i], caseSensitive))
|
|
if (!String::Compare(value, strings[i], caseSensitive))
|
|
|
return i;
|
|
return i;
|
|
|
++i;
|
|
++i;
|
|
|
}
|
|
}
|
|
|
-
|
|
|
|
|
|
|
+
|
|
|
return defaultIndex;
|
|
return defaultIndex;
|
|
|
}
|
|
}
|
|
|
|
|
|