From d4d022517000526421ca2025466733bbebdda72f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Benjamin=20=E2=80=98Touky=E2=80=99=20Huet?= Date: Sun, 15 Feb 2015 07:23:20 +0000 Subject: [PATCH] Removed all the enum macros, because this was shit and admitting that is the first step to global world domination. --- src/base/enum.cpp | 49 ----- src/easymesh/easymesh.h | 60 ++++-- src/easymesh/easymeshbuild.h | 383 +++++++++++++++++++++++----------- src/easymesh/easymeshrender.h | 29 ++- src/lol/base/enum.h | 137 +++--------- src/lol/gpu/shader.h | 93 ++++++--- src/lol/gpu/vertexbuffer.h | 30 ++- src/lol/math/geometry.h | 83 ++++++-- src/lol/sys/file.h | 53 +++-- src/lol/sys/thread.h | 57 +++-- src/messageservice.cpp | 18 +- src/messageservice.h | 58 +++-- src/t/base/enum.cpp | 23 +- src/utils.h | 2 +- 14 files changed, 659 insertions(+), 416 deletions(-) diff --git a/src/base/enum.cpp b/src/base/enum.cpp index e7263b9f..48e848f3 100644 --- a/src/base/enum.cpp +++ b/src/base/enum.cpp @@ -17,55 +17,6 @@ namespace lol * Safe enum helpers */ -map BuildEnumMap(String const &str, char const **custom) -{ - return BuildEnumMap(str.C(), custom); -} -map BuildEnumMap(char const *str, char const **custom) -{ - map ret; - char const *parser = str; - int64_t next_value = 0; - int64_t cur_idx = 0; - - for (;;) - { - /* Find name */ - while (*parser == ' ' || *parser == ',') - ++parser; - if (!*parser) - break; - - /* Parse name */ - char const *name = parser; - while (*parser && *parser != ' ' && *parser != ',' && *parser != '=') - ++parser; - char const *name_end = parser; - - /* Find the value (if any) */ - uint64_t current_value = next_value; - while (*parser == ' ' || *parser == '=') - ++parser; - if (*parser && *parser != ',') - { -#if defined _WIN32 - current_value = _strtoi64(parser, nullptr, 0); -#else - current_value = strtoll(parser, nullptr, 0); -#endif - - while (*parser && *parser != ' ' && *parser != ',') - ++parser; - } - - /* Store in the map */ - ret[current_value] = (!custom) ? (String(name, (int)(name_end - name))) : (String(custom[cur_idx])); - next_value = current_value + 1; - cur_idx++; - } - - return ret; -} } /* namespace lol */ diff --git a/src/easymesh/easymesh.h b/src/easymesh/easymesh.h index f7e1ad27..cf7088b4 100644 --- a/src/easymesh/easymesh.h +++ b/src/easymesh/easymesh.h @@ -24,22 +24,54 @@ namespace lol { +//CSGUsage -------------------------------------------------------------------- /* A safe enum for MeshCSG operations. */ -LOL_SAFE_ENUM(CSGUsage, - Union, - Substract, - SubstractLoss, // will remove B from A, but not add inverted B - And, - Xor -); +struct CSGUsageBase : public StructSafeEnum +{ + enum Type + { + Union, + Substract, + SubstractLoss, // will remove B from A, but not add inverted B + And, + Xor + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Union] = "Union"; + enum_map[Substract] = "Substract"; + enum_map[SubstractLoss] = "SubstractLoss"; + enum_map[And] = "And"; + enum_map[Xor] = "Xor"; + return true; + } +}; +typedef SafeEnum CSGUsage; -LOL_SAFE_ENUM(MeshTransform, - Taper, - Twist, - Bend, - Stretch, - Shear -); +//MeshTransform --------------------------------------------------------------- +struct MeshTransformBase : public StructSafeEnum +{ + enum Type + { + Taper, + Twist, + Bend, + Stretch, + Shear + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Taper] = "Taper"; + enum_map[Twist] = "Twist"; + enum_map[Bend] = "Bend"; + enum_map[Stretch] = "Stretch"; + enum_map[Shear] = "Shear"; + return true; + } +}; +typedef SafeEnum MeshTransform; class EasyMesh : public Mesh { diff --git a/src/easymesh/easymeshbuild.h b/src/easymesh/easymeshbuild.h index 2d3bce07..0d9b3479 100644 --- a/src/easymesh/easymeshbuild.h +++ b/src/easymesh/easymeshbuild.h @@ -20,127 +20,256 @@ namespace lol { -struct MeshBuildOperation +//MeshBuildOperation ---------------------------------------------------------- +struct MeshBuildOperationBase : public StructSafeEnum { - DEF_VALUE + enum Type + { //When this flag is up, negative scaling will not invert faces. - ADD_VALUE_SET(ScaleWinding , (1 << 0)) - ADD_VALUE_SET(CommandRecording , (1 << 1)) - ADD_VALUE_SET(CommandExecution , (1 << 2)) - ADD_VALUE_SET(QuadWeighting , (1 << 3)) - ADD_VALUE_SET(IgnoreQuadWeighting , (1 << 4)) - ADD_VALUE_SET(PostBuildComputeNormals , (1 << 5)) - ADD_VALUE_SET(PreventVertCleanup , (1 << 6)) - - ADD_VALUE_SET(All , 0xffff) - END_E_VALUE - - LOL_DECLARE_ENUM_METHODS(MeshBuildOperation) + ScaleWinding = (1 << 0), + CommandRecording = (1 << 1), + CommandExecution = (1 << 2), + QuadWeighting = (1 << 3), + IgnoreQuadWeighting = (1 << 4), + PostBuildComputeNormals = (1 << 5), + PreventVertCleanup = (1 << 6), + + All = 0xffff, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[ScaleWinding] = "ScaleWinding"; + enum_map[CommandRecording] = "CommandRecording"; + enum_map[CommandExecution] = "CommandExecution"; + enum_map[QuadWeighting] = "QuadWeighting"; + enum_map[IgnoreQuadWeighting] = "IgnoreQuadWeighting"; + enum_map[PostBuildComputeNormals] = "PostBuildComputeNormals"; + enum_map[PreventVertCleanup] = "PreventVertCleanup"; + enum_map[All] = "All"; + return true; + } }; +typedef SafeEnum MeshBuildOperation; -struct EasyMeshCmdType +//EasyMeshCmdType ------------------------------------------------------------- +struct EasyMeshCmdTypeBase : public StructSafeEnum { - DEF_VALUE - ADD_VALUE(MeshCsg) - - ADD_VALUE(LoopStart) - ADD_VALUE(LoopEnd) - ADD_VALUE(OpenBrace) - ADD_VALUE(CloseBrace) - - ADD_VALUE(ScaleWinding) - ADD_VALUE(QuadWeighting) - ADD_VALUE(PostBuildNormal) - ADD_VALUE(PreventVertCleanup) - ADD_VALUE(SetColorA) - ADD_VALUE(SetColorB) - ADD_VALUE(SetVertColor) - - ADD_VALUE(VerticesMerge) - ADD_VALUE(VerticesSeparate) - - ADD_VALUE(Translate) - ADD_VALUE(Rotate) - ADD_VALUE(RadialJitter) - ADD_VALUE(MeshTranform) - ADD_VALUE(Scale) - ADD_VALUE(DupAndScale) - ADD_VALUE(Chamfer) - - ADD_VALUE(SplitTriangles) - ADD_VALUE(SmoothMesh) - - ADD_VALUE(AppendCylinder) - ADD_VALUE(AppendCapsule) - ADD_VALUE(AppendTorus) - ADD_VALUE(AppendBox) - ADD_VALUE(AppendStar) - ADD_VALUE(AppendExpandedStar) - ADD_VALUE(AppendDisc) - ADD_VALUE(AppendSimpleTriangle) - ADD_VALUE(AppendSimpleQuad) - ADD_VALUE(AppendCog) - END_E_VALUE - - LOL_DECLARE_ENUM_METHODS(EasyMeshCmdType) + enum Type + { + MeshCsg, + + LoopStart, + LoopEnd, + OpenBrace, + CloseBrace, + + ScaleWinding, + QuadWeighting, + PostBuildNormal, + PreventVertCleanup, + SetColorA, + SetColorB, + SetVertColor, + + VerticesMerge, + VerticesSeparate, + + Translate, + Rotate, + RadialJitter, + MeshTranform, + Scale, + DupAndScale, + Chamfer, + + SplitTriangles, + SmoothMesh, + + AppendCylinder, + AppendCapsule, + AppendTorus, + AppendBox, + AppendStar, + AppendExpandedStar, + AppendDisc, + AppendSimpleTriangle, + AppendSimpleQuad, + AppendCog, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[MeshCsg] = "MeshCsg"; + enum_map[LoopStart] = "LoopStart"; + enum_map[LoopEnd] = "LoopEnd"; + enum_map[OpenBrace] = "OpenBrace"; + enum_map[CloseBrace] = "CloseBrace"; + enum_map[ScaleWinding] = "ScaleWinding"; + enum_map[QuadWeighting] = "QuadWeighting"; + enum_map[PostBuildNormal] = "PostBuildNormal"; + enum_map[PreventVertCleanup] = "PreventVertCleanup"; + enum_map[SetColorA] = "SetColorA"; + enum_map[SetColorB] = "SetColorB"; + enum_map[SetVertColor] = "SetVertColor"; + enum_map[VerticesMerge] = "VerticesMerge"; + enum_map[VerticesSeparate] = "VerticesSeparate"; + enum_map[Translate] = "Translate"; + enum_map[Rotate] = "Rotate"; + enum_map[RadialJitter] = "RadialJitter"; + enum_map[MeshTranform] = "MeshTranform"; + enum_map[Scale] = "Scale"; + enum_map[DupAndScale] = "DupAndScale"; + enum_map[Chamfer] = "Chamfer"; + enum_map[SplitTriangles] = "SplitTriangles"; + enum_map[SmoothMesh] = "SmoothMesh"; + enum_map[AppendCylinder] = "AppendCylinder"; + enum_map[AppendCapsule] = "AppendCapsule"; + enum_map[AppendTorus] = "AppendTorus"; + enum_map[AppendBox] = "AppendBox"; + enum_map[AppendStar] = "AppendStar"; + enum_map[AppendExpandedStar] = "AppendExpandedStar"; + enum_map[AppendDisc] = "AppendDisc"; + enum_map[AppendSimpleTriangle] = "AppendSimpleTriangle"; + enum_map[AppendSimpleQuad] = "AppendSimpleQuad"; + enum_map[AppendCog] = "AppendCog"; + return true; + } }; +typedef SafeEnum EasyMeshCmdType; -LOL_SAFE_ENUM(MeshType, - Triangle, - Quad, - Box, - Sphere, - Capsule, - Torus, - Cylinder, - Disc, - Star, - ExpandedStar, - Cog, - - MAX -); - -struct TexCoordBuildType +//MeshTypeBase ---------------------------------------------------------------- +struct MeshTypeBase : public StructSafeEnum { - DEF_VALUE - ADD_VALUE_SET(TriangleDefault , 0) - ADD_VALUE_SET(QuadDefault , 0) - ADD_VALUE_SET(BoxDefault , 0) - ADD_VALUE_SET(SphereDefault , 0) - ADD_VALUE_SET(CapsuleDefault , 0) - ADD_VALUE_SET(TorusDefault , 0) - ADD_VALUE_SET(CylinderDefault , 0) - ADD_VALUE_SET(DiscDefault , 0) - ADD_VALUE_SET(StarDefault , 0) - ADD_VALUE_SET(ExpandedStarDefault , 0) - ADD_VALUE_SET(CogDefault , 0) + /* A safe enum for Primitive edge face. */ + enum Type + { + Triangle, + Quad, + Box, + Sphere, + Capsule, + Torus, + Cylinder, + Disc, + Star, + ExpandedStar, + Cog, + + MAX + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Triangle] = "Triangle"; + enum_map[Quad] = "Quad"; + enum_map[Box] = "Box"; + enum_map[Sphere] = "Sphere"; + enum_map[Capsule] = "Capsule"; + enum_map[Torus] = "Torus"; + enum_map[Cylinder] = "Cylinder"; + enum_map[Disc] = "Disc"; + enum_map[Star] = "Star"; + enum_map[ExpandedStar] = "ExpandedStar"; + enum_map[Cog] = "Cog"; + enum_map[MAX] = "MAX"; + return true; + } +}; +typedef SafeEnum MeshType; + +//TexCoordBuildType ----------------------------------------------------------- +struct TexCoordBuildTypeBase : public StructSafeEnum +{ + enum Type + { + TriangleDefault, + QuadDefault, + BoxDefault, + SphereDefault, + CapsuleDefault, + TorusDefault, + CylinderDefault, + DiscDefault, + StarDefault, + ExpandedStarDefault, + CogDefault, //NEVER FORGET TO INCREMENT THIS WHEN ADDING A VALUE - ADD_VALUE_SET(Max , 1) - END_E_VALUE + Max + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[TriangleDefault] = "TriangleDefault"; + enum_map[QuadDefault] = "QuadDefault"; + enum_map[BoxDefault] = "BoxDefault"; + enum_map[SphereDefault] = "SphereDefault"; + enum_map[CapsuleDefault] = "CapsuleDefault"; + enum_map[TorusDefault] = "TorusDefault"; + enum_map[CylinderDefault] = "CylinderDefault"; + enum_map[DiscDefault] = "DiscDefault"; + enum_map[StarDefault] = "StarDefault"; + enum_map[ExpandedStarDefault] = "ExpandedStarDefault"; + enum_map[CogDefault] = "CogDefault"; + enum_map[Max] = "Max"; + return true; + } +}; +typedef SafeEnum TexCoordBuildType; - LOL_DECLARE_ENUM_METHODS(TexCoordBuildType) +//MeshFaceType ---------------------------------------------------------------- +struct MeshFaceTypeBase : public StructSafeEnum +{ + enum Type + { + BoxFront = 0, + QuadDefault = 0, + BoxLeft = 1, + BoxBack = 2, + BoxRight = 3, + BoxTop = 4, + BoxBottom = 5, + + MAX + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[BoxFront] = "BoxFront"; + enum_map[QuadDefault] = "QuadDefault"; + enum_map[BoxLeft] = "BoxLeft"; + enum_map[BoxBack] = "BoxBack"; + enum_map[BoxRight] = "BoxRight"; + enum_map[BoxTop] = "BoxTop"; + enum_map[BoxBottom] = "BoxBottom"; + enum_map[MAX] = "MAX"; + return true; + } }; +typedef SafeEnum MeshFaceType; -LOL_SAFE_ENUM(MeshFaceType, - BoxFront = 0, - QuadDefault = 0, - BoxLeft = 1, - BoxBack = 2, - BoxRight = 3, - BoxTop = 4, - BoxBottom = 5, - - Max -); - -LOL_SAFE_ENUM(TexCoordPos, - BL, // Bottom Left - BR, // Bottom Right - TL, // Top Left - TR // Top Right -); +//TexCoordPos ----------------------------------------------------------------- +struct TexCoordPosBase : public StructSafeEnum +{ + enum Type + { + BL, // Bottom Left + BR, // Bottom Right + TL, // Top Left + TR // Top Right + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[BL] = "BL"; + enum_map[BR] = "BR"; + enum_map[TL] = "TL"; + enum_map[TR] = "TR"; + return true; + } +}; +typedef SafeEnum TexCoordPos; class EasyMeshBuildData { @@ -175,7 +304,7 @@ public: inline vec2 &TexCoordScale2() { return m_texcoord_scale2; } //UV1 - void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type[mt.ToScalar()] & 1); } + void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt.ToScalar()] = (1 << (tcbt.ToScalar() + 1)) | (m_texcoord_build_type[mt.ToScalar()] & 1); } TexCoordBuildType GetTexCoordBuildType(MeshType mt) { uint32_t flag = (uint32_t)((m_texcoord_build_type[mt.ToScalar()] & ~(1)) >> 1); @@ -263,7 +392,7 @@ public: } // UV2 - void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type2[mt.ToScalar()] & 1); } + void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt.ToScalar()] = (1 << (tcbt.ToScalar() + 1)) | (m_texcoord_build_type2[mt.ToScalar()] & 1); } TexCoordBuildType GetTexCoordBuildType2(MeshType mt) { uint32_t flag = ((m_texcoord_build_type2[mt.ToScalar()] & ~(1)) >> 1); @@ -348,10 +477,10 @@ public: return res * m_texcoord_scale + m_texcoord_offset2; } - inline bool IsEnabled(MeshBuildOperation mbo) { return (m_build_flags & mbo) != 0; } - inline void Enable(MeshBuildOperation mbo) { m_build_flags |= mbo; } - inline void Disable(MeshBuildOperation mbo) { m_build_flags &= ~mbo; } - inline void Toggle(MeshBuildOperation mbo) { m_build_flags ^= mbo; } + inline bool IsEnabled(MeshBuildOperation mbo) { return (m_build_flags & mbo.ToScalar()) != 0; } + inline void Enable(MeshBuildOperation mbo) { m_build_flags |= mbo.ToScalar(); } + inline void Disable(MeshBuildOperation mbo) { m_build_flags &= ~mbo.ToScalar(); } + inline void Toggle(MeshBuildOperation mbo) { m_build_flags ^= mbo.ToScalar(); } inline void Set(MeshBuildOperation mbo, bool value) { if (value) Enable(mbo); else Disable(mbo); } public: @@ -372,17 +501,25 @@ public: uint32_t m_build_flags; }; -/* A safe enum for VertexDictionnary operations. */ -struct VDictType +//VDictType -- A safe enum for VertexDictionnary operations. ------------------ +struct VDictTypeBase : public StructSafeEnum { - DEF_VALUE - ADD_VALUE_SET(DoesNotExist , -3) - ADD_VALUE_SET(Alone , -2) - ADD_VALUE_SET(Master , -1) - END_E_VALUE - - LOL_DECLARE_ENUM_METHODS(VDictType) + enum Type + { + DoesNotExist = -3, + Alone = -2, + Master = -1, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[DoesNotExist] = "DoesNotExist"; + enum_map[Alone] = "Alone"; + enum_map[Master] = "Master"; + return true; + } }; +typedef SafeEnum VDictType; /* TODO : replace VDict by a proper Half-edge system */ //a class whose goal is to keep a list of the adjacent vertices for mesh operations purposes diff --git a/src/easymesh/easymeshrender.h b/src/easymesh/easymeshrender.h index b668e555..69e45694 100644 --- a/src/easymesh/easymeshrender.h +++ b/src/easymesh/easymeshrender.h @@ -20,13 +20,28 @@ namespace lol { -// Utility enum for renderers -LOL_SAFE_ENUM(MeshRender, - NeedData, - NeedConvert, - CanRender, - IgnoreRender, -); +//MeshRenderBase -------------------------------------------------------------- +//Utility enum for renderers +struct MeshRenderBase : public StructSafeEnum +{ + enum Type + { + NeedData, + NeedConvert, + CanRender, + IgnoreRender, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[NeedData] = "NeedData"; + enum_map[NeedConvert] = "NeedConvert"; + enum_map[CanRender] = "CanRender"; + enum_map[IgnoreRender] = "IgnoreRender"; + return true; + } +}; +typedef SafeEnum MeshRender; //Vertex datas for easymesh vertex list. //TODO : diff --git a/src/lol/base/enum.h b/src/lol/base/enum.h index 72002bb4..b57eb1ee 100644 --- a/src/lol/base/enum.h +++ b/src/lol/base/enum.h @@ -18,21 +18,29 @@ namespace lol { -extern map BuildEnumMap(char const *str, char const **custom); - -class Enum +////MyType -------------------------------------------------------------------- +//struct MyTypeBase : public StructSafeEnum +//{ +// enum Type +// { +// }; +//protected: +// virtual bool BuildEnumMap(map& enum_map) +// { +// enum_map[] = ""; +// return true; +// } +//}; +//typedef SafeEnum MyType; + +//----------------------------------------------------------------------------- +struct StructSafeEnum { -public: - template - static String EnumToString(T const& parameter) - { - UNUSED(parameter); - // Create your own - ASSERT(0); - return String(); - } +protected: + /* Convert to string stuff */ + virtual bool BuildEnumMap(map& enum_map) { return false; } }; - +//----------------------------------------------------------------------------- template class SafeEnum : public BASE { @@ -47,20 +55,20 @@ public: inline explicit SafeEnum(int i) : m_value(T(i)) {} inline Type ToScalar() const { return m_value; } - /* Convert to string description */ - inline class String ToString() const + /* Convert to string stuff */ + inline class String ToString() { /* FIXME: we all know this isn’t thread safe. But is it really * a big deal? */ static map enum_map; static bool ready = false; - if (!ready) - enum_map = BuildEnumMap(BASE::GetDescription(), BASE::GetCustomString()); - ready = true; - - if (enum_map.has_key((int64_t)m_value)) - return enum_map[(int64_t)m_value]; + if (ready || BuildEnumMap(enum_map)) + { + ready = true; + if (enum_map.has_key((int64_t)m_value)) + return enum_map[(int64_t)m_value]; + } return ""; } @@ -91,92 +99,5 @@ public: } }; -#define LOL_OPEN_SAFE_ENUM(name, ...) \ - struct name ## Base \ - { \ - enum Type {__VA_ARGS__}; \ - protected: \ - static inline char const *GetDescription() { return #__VA_ARGS__; } -#define LOL_SAFE_ENUM_CUSTOM_TOSTRING(...) \ - static inline char const **GetCustomString() \ - { \ - static char const *custom_list[] = { __VA_ARGS__ }; \ - return &custom_list[0]; \ - } -#define LOL_CLOSE_SAFE_ENUM(name) \ - }; \ - typedef SafeEnum name; - -#define LOL_SAFE_ENUM(name, ...) \ - struct name ## Base \ - { \ - enum Type {__VA_ARGS__}; \ - protected: \ - static inline char const *GetDescription() { return #__VA_ARGS__; } \ - static inline char const **GetCustomString() { return nullptr; } \ - }; \ - typedef SafeEnum name; - -//-- STRUCT TEMPLATE: -// enum E { -// DEF_VALUE -// ADD_VALUE(NEW_VALUE) -// ADD_VALUE_SET(NEW_VALUE, VALUE_SET) -// END_E_VALUE -// DEF_TEXT -// ADD_TEXT(NEW_VALUE) -// END_TEXT -// LOL_DECLARE_ENUM_METHODS(E) -// }; - -#define LOL_DECLARE_ENUM_METHODS(E) \ - inline E() : m_value(MAX) {} \ - inline E(Value v) : m_value(v) {} \ - inline E(const int8_t & v) : m_value((Value)v) {} \ - inline E(const int16_t & v) : m_value((Value)v) {} \ - inline E(const int32_t & v) : m_value((Value)v) {} \ - inline E(const int64_t & v) : m_value((Value)v) {} \ - inline E(const uint8_t & v) : m_value((Value)v) {} \ - inline E(const uint16_t & v) : m_value((Value)v) {} \ - inline E(const uint32_t & v) : m_value((Value)v) {} \ - inline E(const uint64_t & v) : m_value((Value)v) {} \ - inline operator Value() { return m_value; } \ - inline int32_t I() { return (int32_t ) m_value; } \ - inline int8_t I8() { return (int8_t ) m_value; } \ - inline int16_t I16() { return (int16_t ) m_value; } \ - inline int32_t I32() { return (int32_t ) m_value; } \ - inline int64_t I64() { return (int64_t ) m_value; } \ - inline uint32_t UI() { return (uint32_t) m_value; } \ - inline uint8_t UI8() { return (uint8_t ) m_value; } \ - inline uint16_t UI16() { return (uint16_t) m_value; } \ - inline uint32_t UI32() { return (uint32_t) m_value; } \ - inline uint64_t UI64() { return (uint64_t) m_value; } \ - bool operator==(const E & v) { return m_value == v.m_value; } \ - bool operator!=(const E & v) { return m_value != v.m_value; } \ - bool operator<(const E & v) { return m_value < v.m_value; } \ - bool operator>(const E & v) { return m_value > v.m_value; } \ - bool operator<=(const E & v) { return m_value <= v.m_value; } \ - bool operator>=(const E & v) { return m_value >= v.m_value; } - -#define DEF_VALUE enum Value { INVALID = -1, -#define ADD_VALUE(NEW_VALUE) NEW_VALUE, -#define ADD_VALUE_SET(NEW_VALUE, VALUE_SET) NEW_VALUE = VALUE_SET, -#define END_E_VALUE MAX } m_value; - -#define DEF_TEXT \ - inline String C() \ - { \ - static const String text[] = { - -#define ADD_TEXT(NEW_TEXT) String(#NEW_TEXT), -#define ADD_TEXT_PADDING String(""), - -#define END_TEXT \ - }; \ - if (m_value < 0 || m_value >= MAX) \ - return "INVALID"; \ - return text[m_value]; \ - }; - } /* namespace lol */ diff --git a/src/lol/gpu/shader.h b/src/lol/gpu/shader.h index 4b7b4446..d497adf8 100644 --- a/src/lol/gpu/shader.h +++ b/src/lol/gpu/shader.h @@ -33,26 +33,57 @@ namespace lol * now there is only TexCoord and not TexCoord0 TexCoord1 etc. because * we can always reorganise the vertex declaration for the indices to * match. If the need arises these enums will be added. */ -LOL_SAFE_ENUM(VertexUsage, - Position, - BlendWeight, - BlendIndices, - Normal, - PointSize, - TexCoord, - TexCoordExt, - Tangent, - Binormal, - TessFactor, - PositionT, - Color, - Fog, - Depth, - Sample, - MAX, -); - -//Enum definitions ------------------------------------------------------------ +//VertexUsageBase ------------------------------------------------------------- +struct VertexUsageBase : public StructSafeEnum +{ + + enum Type + { + Position, + BlendWeight, + BlendIndices, + Normal, + PointSize, + TexCoord, + TexCoordExt, + Tangent, + Binormal, + TessFactor, + PositionT, + Color, + Fog, + Depth, + Sample, + MAX, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Position] = "Position"; + enum_map[BlendWeight] = "BlendWeight"; + enum_map[BlendIndices] = "BlendIndices"; + enum_map[Normal] = "Normal"; + enum_map[PointSize] = "PointSize"; + enum_map[TexCoord] = "TexCoord"; + enum_map[TexCoordExt] = "TexCoordExt"; + enum_map[Tangent] = "Tangent"; + enum_map[Binormal] = "Binormal"; + enum_map[TessFactor] = "TessFactor"; + enum_map[PositionT] = "PositionT"; + enum_map[Color] = "Color"; + enum_map[Fog] = "Fog"; + enum_map[Depth] = "Depth"; + enum_map[Sample] = "Sample"; + enum_map[MAX] = "MAX"; + return true; + } +}; +typedef SafeEnum VertexUsage; + +//----------------------------------------------------------------------------- +//Enum definitions +//----------------------------------------------------------------------------- +//ShaderVariableBase ---------------------------------------------------------- struct ShaderVariableBase { enum Type @@ -68,11 +99,19 @@ struct ShaderVariableBase MAX }; protected: - static inline char const *GetDescription() { return nullptr; } - static inline char const **GetCustomString() { return nullptr; } + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Attribute] = "Attribute"; + enum_map[Uniform] = "Uniform"; + enum_map[Varying] = "Varying"; + enum_map[InOut] = "InOut"; + enum_map[MAX] = "MAX"; + return true; + } }; typedef SafeEnum ShaderVariable; +//ShaderProgramBase ----------------------------------------------------------- struct ShaderProgramBase { enum Type @@ -84,8 +123,14 @@ struct ShaderProgramBase MAX }; protected: - static inline char const *GetDescription() { return nullptr; } - static inline char const **GetCustomString() { return nullptr; } + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Geometry] = "Geometry"; + enum_map[Vertex] = "Vertex"; + enum_map[Pixel] = "Pixel"; + enum_map[MAX] = "MAX"; + return true; + } }; typedef SafeEnum ShaderProgram; diff --git a/src/lol/gpu/vertexbuffer.h b/src/lol/gpu/vertexbuffer.h index 2089174e..13dd1419 100644 --- a/src/lol/gpu/vertexbuffer.h +++ b/src/lol/gpu/vertexbuffer.h @@ -39,13 +39,29 @@ private: /* A safe enum to indicate what kind of primitive to draw. Used in * VertexDeclaration::DrawElements() for instance. */ -LOL_SAFE_ENUM(MeshPrimitive, - Triangles, - TriangleStrips, - TriangleFans, - Points, - Lines, -); +//MeshPrimitiveBase -- A safe enum for Primitive edge face. ------------------- +struct MeshPrimitiveBase : public StructSafeEnum +{ + enum Type + { + Triangles, + TriangleStrips, + TriangleFans, + Points, + Lines, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Triangles] = "Triangles"; + enum_map[TriangleStrips] = "TriangleStrips"; + enum_map[TriangleFans] = "TriangleFans"; + enum_map[Points] = "Points"; + enum_map[Lines] = "Lines"; + return true; + } +}; +typedef SafeEnum MeshPrimitive; class VertexStreamBase { diff --git a/src/lol/math/geometry.h b/src/lol/math/geometry.h index cf734f2f..42f5a33f 100644 --- a/src/lol/math/geometry.h +++ b/src/lol/math/geometry.h @@ -27,28 +27,43 @@ namespace lol { //AxisBase -------------------------------------------------------------------- -struct AxisBase + struct AxisBase : public StructSafeEnum { enum Type { X = 0, Y, Z, MAX, XY = 2, XYZ = 3, }; protected: - static inline char const *GetDescription() { return "X,Y,Z,MAX,XY,XYZ"; } - static inline char const **GetCustomString() { return nullptr; } + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[X] = "X"; + enum_map[Y] = "Y"; + enum_map[Z] = "Z"; + enum_map[MAX] = "MAX"; + enum_map[XY] = "XY"; + enum_map[XYZ] = "XYZ"; + return true; + } }; typedef SafeEnum Axis; //DirectionBase --------------------------------------------------------------- -struct DirectionBase +struct DirectionBase : public StructSafeEnum { enum Type { Up = 0, Down, Left, Right, MAX, }; protected: - static inline char const *GetDescription() { return "Up,Down,Left,Right,MAX"; } - static inline char const **GetCustomString() { return nullptr; } + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Up] = "Up"; + enum_map[Down] = "Down"; + enum_map[Left] = "Left"; + enum_map[Right] = "Right"; + enum_map[MAX] = "MAX"; + return true; + } }; typedef SafeEnum Direction; @@ -265,18 +280,30 @@ bool TestRayVsTriangle(vec3 const &ray_point, vec3 const &ray_dir, vec3 const &tri_p0, vec3 const &tri_p1, vec3 const &tri_p2, vec3 &vi); -struct RayIntersect +//RayIntersect ---------------------------------------------------------------- +struct RayIntersectBase : public StructSafeEnum { - DEF_VALUE - ADD_VALUE(Nothing) - ADD_VALUE(All) - ADD_VALUE(None) - ADD_VALUE(P0) - ADD_VALUE(P1) - END_E_VALUE - - LOL_DECLARE_ENUM_METHODS(RayIntersect) + enum Type + { + Nothing, + All, + None, + P0, + P1, + }; + //LOL_DECLARE_ENUM_METHODS(RayIntersectBase) +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Nothing] = "Nothing"; + enum_map[All] = "All"; + enum_map[None] = "None"; + enum_map[P0] = "P0"; + enum_map[P1] = "P1"; + return true; + } }; +typedef SafeEnum RayIntersect; #define RAY_ISECT_NOTHING 0 #define RAY_ISECT_ALL 1 @@ -322,12 +349,24 @@ bool TestRayVsPlane(const TV &ray_p0, const TV &ray_p1, return true; } -/* A safe enum for Primitive edge face. */ -LOL_SAFE_ENUM(PlaneIntersection, - Back, - Front, - Plane, -); +//PlaneIntersectionBase ------------------------------------------------------- +struct PlaneIntersectionBase : public StructSafeEnum +{ + /* A safe enum for Primitive edge face. */ + enum Type + { + Back, Front, Plane, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Back] = "Back"; + enum_map[Front] = "Front"; + enum_map[Plane] = "Plane"; + return true; + } +}; +typedef SafeEnum PlaneIntersection; //Point/Plane : Normal must be given normalized. template diff --git a/src/lol/sys/file.h b/src/lol/sys/file.h index 0f6902ac..c5686e71 100644 --- a/src/lol/sys/file.h +++ b/src/lol/sys/file.h @@ -20,18 +20,47 @@ namespace lol { -LOL_SAFE_ENUM(FileAccess, - Read = 0, - Write -); - -LOL_SAFE_ENUM(StreamType, - StdIn, - StdOut, - StdErr, - File, - FileBinary -); +//FileAccessBase -------------------------------------------------------------- +struct FileAccessBase : public StructSafeEnum +{ + enum Type + { + Read = 0, + Write + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[Read] = "Read"; + enum_map[Write] = "Write"; + return true; + } +}; +typedef SafeEnum FileAccess; + +//StreamTypeBase -------------------------------------------------------------- +struct StreamTypeBase : public StructSafeEnum +{ + enum Type + { + StdIn, + StdOut, + StdErr, + File, + FileBinary + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[StdIn] = "StdIn"; + enum_map[StdOut] = "StdOut"; + enum_map[StdErr] = "StdErr"; + enum_map[File] = "File"; + enum_map[FileBinary] = "FileBinary"; + return true; + } +}; +typedef SafeEnum StreamType; class File { diff --git a/src/lol/sys/thread.h b/src/lol/sys/thread.h index b4386e57..88d04431 100644 --- a/src/lol/sys/thread.h +++ b/src/lol/sys/thread.h @@ -46,25 +46,50 @@ public: virtual ~thread() {} }; -struct ThreadStatus +//ThreadStatus ---------------------------------------------------------------- +struct ThreadStatusBase : public StructSafeEnum { - DEF_VALUE - ADD_VALUE(NOTHING) - ADD_VALUE(THREAD_STARTED) - ADD_VALUE(THREAD_STOPPED) - END_E_VALUE - - LOL_DECLARE_ENUM_METHODS(ThreadStatus) + enum Type + { + NOTHING, + THREAD_STARTED, + THREAD_STOPPED, + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[NOTHING] = "NOTHING"; + enum_map[THREAD_STARTED] = "THREAD_STARTED"; + enum_map[THREAD_STOPPED] = "THREAD_STOPPED"; + return true; + } }; +typedef SafeEnum ThreadStatus; -LOL_SAFE_ENUM(ThreadJobType, - NONE, - WORK_TODO, - WORK_DONE, - WORK_FAILED, - WORK_FETCHED, - THREAD_STOP -); +struct ThreadJobTypeBase : public StructSafeEnum +{ + enum Type + { + NONE, + WORK_TODO, + WORK_DONE, + WORK_FAILED, + WORK_FETCHED, + THREAD_STOP + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[NONE] = "NONE"; + enum_map[WORK_TODO] = "WORK_TODO"; + enum_map[WORK_DONE] = "WORK_DONE"; + enum_map[WORK_FAILED] = "WORK_FAILED"; + enum_map[WORK_FETCHED] = "WORK_FETCHED"; + enum_map[THREAD_STOP] = "THREAD_STOP"; + return true; + } +}; +typedef SafeEnum ThreadJobType; class ThreadJob { diff --git a/src/messageservice.cpp b/src/messageservice.cpp index 0682eef1..15737f72 100644 --- a/src/messageservice.cpp +++ b/src/messageservice.cpp @@ -63,7 +63,7 @@ bool MessageService::Send(MessageBucket id, const String& message) { if (g_messageservice) { - ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count()); + ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count()); return g_messageservice->Send(id, message.C()); } return false; @@ -73,9 +73,9 @@ bool MessageService::Send(MessageBucket id, const char* message) { if (g_messageservice) { - ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count()); + ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count()); MessageService& g = *g_messageservice; - array& bucket = g.m_bucket[id]; + array& bucket = g.m_bucket[id.ToScalar()]; bucket << MessageList(time(nullptr), String(message)); return true; } @@ -87,7 +87,7 @@ bool MessageService::FetchFirst(MessageBucket id, String& message) { if (g_messageservice) { - ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count()); + ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count()); time_t timestamp; return g_messageservice->FetchFirst(id, message, timestamp); } @@ -98,9 +98,9 @@ bool MessageService::FetchFirst(MessageBucket id, String& message, time_t& times { if (g_messageservice) { - ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count()); + ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count()); MessageService& g = *g_messageservice; - array& bucket = g.m_bucket[id]; + array& bucket = g.m_bucket[id.ToScalar()]; if (bucket.Count()) { @@ -118,7 +118,7 @@ bool MessageService::FetchAll(MessageBucket id, String& message) { if (g_messageservice) { - ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count()); + ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count()); time_t timestamp; return g_messageservice->FetchAll(id, message, timestamp); } @@ -129,9 +129,9 @@ bool MessageService::FetchAll(MessageBucket id, String& message, time_t& first_t { if (g_messageservice) { - ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count()); + ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count()); MessageService& g = *g_messageservice; - array& bucket = g.m_bucket[id]; + array& bucket = g.m_bucket[id.ToScalar()]; message = String(""); if (bucket.Count()) diff --git a/src/messageservice.h b/src/messageservice.h index e5300734..572715b1 100644 --- a/src/messageservice.h +++ b/src/messageservice.h @@ -19,27 +19,47 @@ namespace lol { -// Utility enum for message service -struct MessageBucket +//MessageBucket -- Utility enum for message service --------------------------- +struct MessageBucketBase : public StructSafeEnum { - DEF_VALUE - ADD_VALUE(AppIn) - ADD_VALUE(AppOut) - - ADD_VALUE(Bckt0) - ADD_VALUE(Bckt1) - ADD_VALUE(Bckt2) - ADD_VALUE(Bckt3) - ADD_VALUE(Bckt4) - ADD_VALUE(Bckt5) - ADD_VALUE(Bckt6) - ADD_VALUE(Bckt7) - ADD_VALUE(Bckt8) - ADD_VALUE(Bckt9) - END_E_VALUE - - LOL_DECLARE_ENUM_METHODS(MessageBucket) + enum Type + { + AppIn, + AppOut, + + Bckt0, + Bckt1, + Bckt2, + Bckt3, + Bckt4, + Bckt5, + Bckt6, + Bckt7, + Bckt8, + Bckt9, + + MAX + }; +protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[AppIn] = "AppIn"; + enum_map[AppOut] = "AppOut"; + enum_map[Bckt0] = "Bckt0"; + enum_map[Bckt1] = "Bckt1"; + enum_map[Bckt2] = "Bckt2"; + enum_map[Bckt3] = "Bckt3"; + enum_map[Bckt4] = "Bckt4"; + enum_map[Bckt5] = "Bckt5"; + enum_map[Bckt6] = "Bckt6"; + enum_map[Bckt7] = "Bckt7"; + enum_map[Bckt8] = "Bckt8"; + enum_map[Bckt9] = "Bckt9"; + enum_map[MAX] = "MAX"; + return true; + } }; +typedef SafeEnum MessageBucket; //Message list container with time in it struct MessageList diff --git a/src/t/base/enum.cpp b/src/t/base/enum.cpp index ca43a7d0..fd1edec7 100644 --- a/src/t/base/enum.cpp +++ b/src/t/base/enum.cpp @@ -23,11 +23,24 @@ lolunit_declare_fixture(EnumTest) lolunit_declare_test(EnumToString) { - LOL_SAFE_ENUM(MyEnum, - First = -10, - Second, - Third = 5, - ); + struct MyEnumBase : public StructSafeEnum + { + enum Type + { + First = -10, + Second, + Third = 5, + }; + protected: + virtual bool BuildEnumMap(map& enum_map) + { + enum_map[First] = "First"; + enum_map[Second] = "Second"; + enum_map[Third] = "Third"; + return true; + } + }; + typedef SafeEnum MyEnum; MyEnum e = MyEnum::First; lolunit_assert(e.ToString() == "First"); diff --git a/src/utils.h b/src/utils.h index 28944aa9..896d5bdf 100644 --- a/src/utils.h +++ b/src/utils.h @@ -60,7 +60,7 @@ template< class T > inline int GetRandom(array src) return (r_total > .0f)?(r_j):(-1); } -// Gets the value for the given LOL_SAFE_ENUM type. +// Gets the value for the given enum type. template inline T FindValue(const char* name) { String n = name;