mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
235 lines
8.5 KiB
C++
235 lines
8.5 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _PROPERTYPARSING_H_
|
|
#define _PROPERTYPARSING_H_
|
|
|
|
class ColorI;
|
|
class LinearColorF;
|
|
class Point2I;
|
|
class Point2F;
|
|
class Point3F;
|
|
class Point4F;
|
|
class Point3I;
|
|
class Point4I;
|
|
class RectI;
|
|
class RectF;
|
|
class Box3I;
|
|
class Box3F;
|
|
#ifndef USE_TEMPLATE_MATRIX
|
|
class MatrixF;
|
|
#else
|
|
template<typename DATA_TYPE, U32 rows, U32 cols> class Matrix;
|
|
typedef Matrix<F32, 4, 4> MatrixF;
|
|
#endif
|
|
class AngAxisF;
|
|
class QuatF;
|
|
class String;
|
|
class FileName;
|
|
class SimObject;
|
|
class SimObjectType;
|
|
template<class T> class Vector;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// String scan/print methods
|
|
//
|
|
// Macros in propertyImplementation.h point the ConcretePropertyDefinition scan/print delegates to these functions.
|
|
//
|
|
namespace PropertyInfo
|
|
{
|
|
// String
|
|
bool default_scan(const String &data, String & result);
|
|
bool default_print(String & result, const String & data);
|
|
|
|
// Bool
|
|
bool default_scan(const String &data, bool & result);
|
|
bool default_print(String & result, const bool & data);
|
|
|
|
// S32/F32/U32
|
|
bool default_scan(const String &data, F32 & result);
|
|
bool default_print(String & result, const F32 & data);
|
|
bool default_scan(const String &data, U32 & result);
|
|
bool default_print(String & result, const U32 & data);
|
|
bool default_scan(const String &data, S32 & result);
|
|
bool default_print(String & result, const S32 & data);
|
|
|
|
// Vector<S32/F32/U32>
|
|
bool default_scan(const String &data, Vector<F32> & result);
|
|
bool default_print(String & result, const Vector<F32> & data);
|
|
bool default_scan(const String &data, Vector<U32> & result);
|
|
bool default_print(String & result, const Vector<U32> & data);
|
|
bool default_scan(const String &data, Vector<S32> & result);
|
|
bool default_print(String & result, const Vector<S32> & data);
|
|
|
|
// Math Points
|
|
bool default_scan(const String &data, Point2F & result);
|
|
bool default_print(String & result, const Point2F & data);
|
|
bool default_scan(const String &data, Point2I & result);
|
|
bool default_print(String & result, const Point2I & data);
|
|
bool default_scan(const String &data, Point3F & result);
|
|
bool default_print(String & result, const Point3F & data);
|
|
bool default_scan(const String &data, Point3I & result);
|
|
bool default_print(String & result, const Point3I & data);
|
|
bool default_scan(const String &data, Point4F & result);
|
|
bool default_print(String & result, const Point4F & data);
|
|
bool default_scan(const String &data, Point4I & result);
|
|
bool default_print(String & result, const Point4I & data);
|
|
|
|
// Math Boxs & Rectangles
|
|
bool default_scan(const String &data, RectI & result);
|
|
bool default_print(String & result, const RectI & data);
|
|
bool default_scan(const String &data, RectF & result);
|
|
bool default_print(String & result, const RectF & data);
|
|
bool default_scan(const String &data, Box3I & result);
|
|
bool default_print(String & result, const Box3I & data);
|
|
bool default_scan(const String &data, Box3F & result);
|
|
bool default_print(String & result, const Box3F & data);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool default_scan( const String &data, AngAxisF & result );
|
|
bool default_print( String & result, const AngAxisF & data );
|
|
|
|
bool default_scan( const String &data, QuatF & result );
|
|
bool default_print( String & result, const QuatF & data );
|
|
|
|
bool default_scan( const String &data, MatrixF & result );
|
|
bool default_print( String & result, const MatrixF & data );
|
|
|
|
// Colors
|
|
bool default_scan(const String &data, LinearColorF & result);
|
|
bool default_print(String & result, const LinearColorF & data);
|
|
bool default_scan(const String &data, ColorI & result);
|
|
bool default_print(String & result, const ColorI & data);
|
|
|
|
// filename handler
|
|
bool default_scan(const String &data, FileName & result);
|
|
bool default_print(String & result, const FileName & data);
|
|
|
|
// SimObjectType
|
|
bool default_scan(const String &data, SimObjectType & result);
|
|
bool default_print(String & result, SimObjectType const & data);
|
|
|
|
// SimObject
|
|
bool default_scan(const String &data, SimObject * & result);
|
|
bool default_print(String & result, SimObject * const & data);
|
|
|
|
template<class T>
|
|
inline bool typed_simobject_scan(const String &data, T * & result)
|
|
{
|
|
SimObject * obj;
|
|
result = default_scan(data,obj)? dynamic_cast<T*>(obj) : NULL;
|
|
return result;
|
|
}
|
|
|
|
template<class T>
|
|
inline bool typed_simobject_print(String & result, T * const & data)
|
|
{
|
|
return default_print(result,data);
|
|
}
|
|
|
|
bool hex_scan(const String & string, U32 & hex);
|
|
bool hex_print(String & string, const U32 & hex);
|
|
bool hex_scan(const String & string, S32 & hex);
|
|
bool hex_print(String & string, const S32 & hex);
|
|
|
|
bool hex_scan(const String & string, U16 & hex);
|
|
bool hex_print(String & string, const U16 & hex);
|
|
bool hex_scan(const String & string, S16 & hex);
|
|
bool hex_print(String & string, const S16 & hex);
|
|
|
|
bool hex_scan(const String & string, U8 & hex);
|
|
bool hex_print(String & string, const U8 & hex);
|
|
bool hex_scan(const String & string, S8 & hex);
|
|
bool hex_print(String & string, const S8 & hex);
|
|
|
|
bool default_print(String & result, SimObjectType * const & data);
|
|
|
|
template<typename T, size_t count>
|
|
char* FormatPropertyBuffer(const void* dataPtr, char* buffer, U32 bufSize)
|
|
{
|
|
const T* values = reinterpret_cast<const T*>(dataPtr);
|
|
char* ptr = buffer;
|
|
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
S32 written = 0;
|
|
|
|
if constexpr (std::is_same_v<T, int> || std::is_same_v<T, S32>)
|
|
written = dSprintf(ptr, bufSize - (ptr - buffer), "%d", values[i]);
|
|
else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, F32>)
|
|
written = dSprintf(ptr, bufSize - (ptr - buffer), "%g", values[i]);
|
|
else
|
|
AssertFatal(sizeof(T) == 0, "Unsupported type in FormatProperty");
|
|
|
|
ptr += written;
|
|
if (i < count - 1)
|
|
*ptr++ = ' ';
|
|
}
|
|
|
|
return ptr; // return end of written string for chaining
|
|
}
|
|
|
|
template<typename T, size_t count>
|
|
const char* FormatProperty(const void* dataPtr)
|
|
{
|
|
static const U32 bufSize = 256;
|
|
char* buffer = Con::getReturnBuffer(bufSize);
|
|
FormatPropertyBuffer<T,count>(dataPtr, buffer, bufSize);
|
|
return buffer;
|
|
}
|
|
|
|
template<typename T, size_t count>
|
|
inline bool ParseProperty(char* str, T(&out)[count])
|
|
{
|
|
|
|
size_t index = 0;
|
|
char* tok = dStrtok(str, " \t");
|
|
|
|
while (tok && index < count)
|
|
{
|
|
if constexpr (std::is_same_v<T, int> || std::is_same_v<T, S32>)
|
|
{
|
|
out[index++] = mRound(dAtof(tok));
|
|
}
|
|
else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, F32>)
|
|
{
|
|
out[index++] = dAtof(tok);
|
|
}
|
|
else
|
|
{
|
|
AssertFatal(sizeof(T) == 0, "Unsupported type in PropertyInfo::ParseProperty");
|
|
}
|
|
|
|
tok = dStrtok(nullptr, " \t");
|
|
}
|
|
|
|
return index == count;
|
|
}
|
|
|
|
}
|
|
|
|
// Default Scan/print definition
|
|
#define DEFINE_PROPERTY_DEFAULT_PRINT(dataType) bool PropertyInfo::default_print(String & resultString, dataType const & dataTyped)
|
|
#define DEFINE_PROPERTY_DEFAULT_SCAN(dataType) bool PropertyInfo::default_scan(const String &dataString, dataType & resultTyped)
|
|
|
|
#endif // _PROPERTYPARSING_H_
|