Changeset 3816


Ignore:
Timestamp:
Feb 15, 2015, 8:23:20 AM (7 years ago)
Author:
touky
Message:

Removed all the enum macros, because this was shit and admitting that is the first step to global world domination.

Location:
trunk/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/base/enum.cpp

    r3600 r3816  
    1818 */
    1919
    20 map<int64_t, String> BuildEnumMap(String const &str, char const **custom)
    21 {
    22     return BuildEnumMap(str.C(), custom);
    23 }
    24 map<int64_t, String> BuildEnumMap(char const *str, char const **custom)
    25 {
    26     map<int64_t, String> ret;
    27     char const *parser = str;
    28     int64_t next_value = 0;
    29     int64_t cur_idx = 0;
    30 
    31     for (;;)
    32     {
    33         /* Find name */
    34         while (*parser == ' ' || *parser == ',')
    35             ++parser;
    36         if (!*parser)
    37             break;
    38 
    39         /* Parse name */
    40         char const *name = parser;
    41         while (*parser && *parser != ' ' && *parser != ',' && *parser != '=')
    42             ++parser;
    43         char const *name_end = parser;
    44 
    45         /* Find the value (if any) */
    46         uint64_t current_value = next_value;
    47         while (*parser == ' ' || *parser == '=')
    48             ++parser;
    49         if (*parser && *parser != ',')
    50         {
    51 #if defined _WIN32
    52             current_value = _strtoi64(parser, nullptr, 0);
    53 #else
    54             current_value = strtoll(parser, nullptr, 0);
    55 #endif
    56 
    57             while (*parser && *parser != ' ' && *parser != ',')
    58                 ++parser;
    59         }
    60 
    61         /* Store in the map */
    62         ret[current_value] = (!custom) ? (String(name, (int)(name_end - name))) : (String(custom[cur_idx]));
    63         next_value = current_value + 1;
    64         cur_idx++;
    65     }
    66 
    67     return ret;
    68 }
    6920
    7021} /* namespace lol */
  • trunk/src/easymesh/easymesh.h

    r3602 r3816  
    2525{
    2626
     27//CSGUsage --------------------------------------------------------------------
    2728/* A safe enum for MeshCSG operations. */
    28 LOL_SAFE_ENUM(CSGUsage,
    29     Union,
    30     Substract,
    31     SubstractLoss, // will remove B from A, but not add inverted B
    32     And,
    33     Xor
    34 );
    35 
    36 LOL_SAFE_ENUM(MeshTransform,
    37     Taper,
    38     Twist,
    39     Bend,
    40     Stretch,
    41     Shear
    42 );
     29struct CSGUsageBase : public StructSafeEnum
     30{
     31    enum Type
     32    {
     33        Union,
     34        Substract,
     35        SubstractLoss, // will remove B from A, but not add inverted B
     36        And,
     37        Xor
     38    };
     39protected:
     40    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     41    {
     42        enum_map[Union] = "Union";
     43        enum_map[Substract] = "Substract";
     44        enum_map[SubstractLoss] = "SubstractLoss";
     45        enum_map[And] = "And";
     46        enum_map[Xor] = "Xor";
     47        return true;
     48    }
     49};
     50typedef SafeEnum<CSGUsageBase> CSGUsage;
     51
     52//MeshTransform ---------------------------------------------------------------
     53struct MeshTransformBase : public StructSafeEnum
     54{
     55    enum Type
     56    {
     57        Taper,
     58        Twist,
     59        Bend,
     60        Stretch,
     61        Shear
     62    };
     63protected:
     64    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     65    {
     66        enum_map[Taper] = "Taper";
     67        enum_map[Twist] = "Twist";
     68        enum_map[Bend] = "Bend";
     69        enum_map[Stretch] = "Stretch";
     70        enum_map[Shear] = "Shear";
     71        return true;
     72    }
     73};
     74typedef SafeEnum<MeshTransformBase> MeshTransform;
    4375
    4476class EasyMesh : public Mesh
  • trunk/src/easymesh/easymeshbuild.h

    r3580 r3816  
    2121{
    2222
    23 struct MeshBuildOperation
    24 {
    25     DEF_VALUE
     23//MeshBuildOperation ----------------------------------------------------------
     24struct MeshBuildOperationBase : public StructSafeEnum
     25{
     26    enum Type
     27    {
    2628        //When this flag is up, negative scaling will not invert faces.
    27         ADD_VALUE_SET(ScaleWinding                , (1 << 0))
    28         ADD_VALUE_SET(CommandRecording            , (1 << 1))
    29         ADD_VALUE_SET(CommandExecution            , (1 << 2))
    30         ADD_VALUE_SET(QuadWeighting               , (1 << 3))
    31         ADD_VALUE_SET(IgnoreQuadWeighting         , (1 << 4))
    32         ADD_VALUE_SET(PostBuildComputeNormals     , (1 << 5))
    33         ADD_VALUE_SET(PreventVertCleanup          , (1 << 6))
    34 
    35         ADD_VALUE_SET(All                         , 0xffff)
    36     END_E_VALUE
    37 
    38     LOL_DECLARE_ENUM_METHODS(MeshBuildOperation)
    39 };
    40 
    41 struct EasyMeshCmdType
    42 {
    43     DEF_VALUE
    44         ADD_VALUE(MeshCsg)
    45 
    46         ADD_VALUE(LoopStart)
    47         ADD_VALUE(LoopEnd)
    48         ADD_VALUE(OpenBrace)
    49         ADD_VALUE(CloseBrace)
    50 
    51         ADD_VALUE(ScaleWinding)
    52         ADD_VALUE(QuadWeighting)
    53         ADD_VALUE(PostBuildNormal)
    54         ADD_VALUE(PreventVertCleanup)
    55         ADD_VALUE(SetColorA)
    56         ADD_VALUE(SetColorB)
    57         ADD_VALUE(SetVertColor)
    58 
    59         ADD_VALUE(VerticesMerge)
    60         ADD_VALUE(VerticesSeparate)
    61 
    62         ADD_VALUE(Translate)
    63         ADD_VALUE(Rotate)
    64         ADD_VALUE(RadialJitter)
    65         ADD_VALUE(MeshTranform)
    66         ADD_VALUE(Scale)
    67         ADD_VALUE(DupAndScale)
    68         ADD_VALUE(Chamfer)
    69 
    70         ADD_VALUE(SplitTriangles)
    71         ADD_VALUE(SmoothMesh)
    72 
    73         ADD_VALUE(AppendCylinder)
    74         ADD_VALUE(AppendCapsule)
    75         ADD_VALUE(AppendTorus)
    76         ADD_VALUE(AppendBox)
    77         ADD_VALUE(AppendStar)
    78         ADD_VALUE(AppendExpandedStar)
    79         ADD_VALUE(AppendDisc)
    80         ADD_VALUE(AppendSimpleTriangle)
    81         ADD_VALUE(AppendSimpleQuad)
    82         ADD_VALUE(AppendCog)
    83     END_E_VALUE
    84 
    85     LOL_DECLARE_ENUM_METHODS(EasyMeshCmdType)
    86 };
    87 
    88 LOL_SAFE_ENUM(MeshType,
    89     Triangle,
    90     Quad,
    91     Box,
    92     Sphere,
    93     Capsule,
    94     Torus,
    95     Cylinder,
    96     Disc,
    97     Star,
    98     ExpandedStar,
    99     Cog,
    100 
    101     MAX
    102 );
    103 
    104 struct TexCoordBuildType
    105 {
    106     DEF_VALUE
    107         ADD_VALUE_SET(TriangleDefault     , 0)
    108         ADD_VALUE_SET(QuadDefault         , 0)
    109         ADD_VALUE_SET(BoxDefault          , 0)
    110         ADD_VALUE_SET(SphereDefault       , 0)
    111         ADD_VALUE_SET(CapsuleDefault      , 0)
    112         ADD_VALUE_SET(TorusDefault        , 0)
    113         ADD_VALUE_SET(CylinderDefault     , 0)
    114         ADD_VALUE_SET(DiscDefault         , 0)
    115         ADD_VALUE_SET(StarDefault         , 0)
    116         ADD_VALUE_SET(ExpandedStarDefault , 0)
    117         ADD_VALUE_SET(CogDefault          , 0)
     29        ScaleWinding = (1 << 0),
     30        CommandRecording = (1 << 1),
     31        CommandExecution = (1 << 2),
     32        QuadWeighting = (1 << 3),
     33        IgnoreQuadWeighting = (1 << 4),
     34        PostBuildComputeNormals = (1 << 5),
     35        PreventVertCleanup = (1 << 6),
     36
     37        All = 0xffff,
     38    };
     39protected:
     40    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     41    {
     42        enum_map[ScaleWinding] = "ScaleWinding";
     43        enum_map[CommandRecording] = "CommandRecording";
     44        enum_map[CommandExecution] = "CommandExecution";
     45        enum_map[QuadWeighting] = "QuadWeighting";
     46        enum_map[IgnoreQuadWeighting] = "IgnoreQuadWeighting";
     47        enum_map[PostBuildComputeNormals] = "PostBuildComputeNormals";
     48        enum_map[PreventVertCleanup] = "PreventVertCleanup";
     49        enum_map[All] = "All";
     50        return true;
     51    }
     52};
     53typedef SafeEnum<MeshBuildOperationBase> MeshBuildOperation;
     54
     55//EasyMeshCmdType -------------------------------------------------------------
     56struct EasyMeshCmdTypeBase : public StructSafeEnum
     57{
     58    enum Type
     59    {
     60        MeshCsg,
     61
     62        LoopStart,
     63        LoopEnd,
     64        OpenBrace,
     65        CloseBrace,
     66
     67        ScaleWinding,
     68        QuadWeighting,
     69        PostBuildNormal,
     70        PreventVertCleanup,
     71        SetColorA,
     72        SetColorB,
     73        SetVertColor,
     74
     75        VerticesMerge,
     76        VerticesSeparate,
     77
     78        Translate,
     79        Rotate,
     80        RadialJitter,
     81        MeshTranform,
     82        Scale,
     83        DupAndScale,
     84        Chamfer,
     85
     86        SplitTriangles,
     87        SmoothMesh,
     88
     89        AppendCylinder,
     90        AppendCapsule,
     91        AppendTorus,
     92        AppendBox,
     93        AppendStar,
     94        AppendExpandedStar,
     95        AppendDisc,
     96        AppendSimpleTriangle,
     97        AppendSimpleQuad,
     98        AppendCog,
     99    };
     100protected:
     101    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     102    {
     103        enum_map[MeshCsg] = "MeshCsg";
     104        enum_map[LoopStart] = "LoopStart";
     105        enum_map[LoopEnd] = "LoopEnd";
     106        enum_map[OpenBrace] = "OpenBrace";
     107        enum_map[CloseBrace] = "CloseBrace";
     108        enum_map[ScaleWinding] = "ScaleWinding";
     109        enum_map[QuadWeighting] = "QuadWeighting";
     110        enum_map[PostBuildNormal] = "PostBuildNormal";
     111        enum_map[PreventVertCleanup] = "PreventVertCleanup";
     112        enum_map[SetColorA] = "SetColorA";
     113        enum_map[SetColorB] = "SetColorB";
     114        enum_map[SetVertColor] = "SetVertColor";
     115        enum_map[VerticesMerge] = "VerticesMerge";
     116        enum_map[VerticesSeparate] = "VerticesSeparate";
     117        enum_map[Translate] = "Translate";
     118        enum_map[Rotate] = "Rotate";
     119        enum_map[RadialJitter] = "RadialJitter";
     120        enum_map[MeshTranform] = "MeshTranform";
     121        enum_map[Scale] = "Scale";
     122        enum_map[DupAndScale] = "DupAndScale";
     123        enum_map[Chamfer] = "Chamfer";
     124        enum_map[SplitTriangles] = "SplitTriangles";
     125        enum_map[SmoothMesh] = "SmoothMesh";
     126        enum_map[AppendCylinder] = "AppendCylinder";
     127        enum_map[AppendCapsule] = "AppendCapsule";
     128        enum_map[AppendTorus] = "AppendTorus";
     129        enum_map[AppendBox] = "AppendBox";
     130        enum_map[AppendStar] = "AppendStar";
     131        enum_map[AppendExpandedStar] = "AppendExpandedStar";
     132        enum_map[AppendDisc] = "AppendDisc";
     133        enum_map[AppendSimpleTriangle] = "AppendSimpleTriangle";
     134        enum_map[AppendSimpleQuad] = "AppendSimpleQuad";
     135        enum_map[AppendCog] = "AppendCog";
     136        return true;
     137    }
     138};
     139typedef SafeEnum<EasyMeshCmdTypeBase> EasyMeshCmdType;
     140
     141//MeshTypeBase ----------------------------------------------------------------
     142struct MeshTypeBase : public StructSafeEnum
     143{
     144    /* A safe enum for Primitive edge face. */
     145    enum Type
     146    {
     147        Triangle,
     148        Quad,
     149        Box,
     150        Sphere,
     151        Capsule,
     152        Torus,
     153        Cylinder,
     154        Disc,
     155        Star,
     156        ExpandedStar,
     157        Cog,
     158
     159        MAX
     160    };
     161protected:
     162    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     163    {
     164        enum_map[Triangle] = "Triangle";
     165        enum_map[Quad] = "Quad";
     166        enum_map[Box] = "Box";
     167        enum_map[Sphere] = "Sphere";
     168        enum_map[Capsule] = "Capsule";
     169        enum_map[Torus] = "Torus";
     170        enum_map[Cylinder] = "Cylinder";
     171        enum_map[Disc] = "Disc";
     172        enum_map[Star] = "Star";
     173        enum_map[ExpandedStar] = "ExpandedStar";
     174        enum_map[Cog] = "Cog";
     175        enum_map[MAX] = "MAX";
     176        return true;
     177    }
     178};
     179typedef SafeEnum<MeshTypeBase> MeshType;
     180
     181//TexCoordBuildType -----------------------------------------------------------
     182struct TexCoordBuildTypeBase : public StructSafeEnum
     183{
     184    enum Type
     185    {
     186        TriangleDefault,
     187        QuadDefault,
     188        BoxDefault,
     189        SphereDefault,
     190        CapsuleDefault,
     191        TorusDefault,
     192        CylinderDefault,
     193        DiscDefault,
     194        StarDefault,
     195        ExpandedStarDefault,
     196        CogDefault,
    118197
    119198        //NEVER FORGET TO INCREMENT THIS WHEN ADDING A VALUE
    120         ADD_VALUE_SET(Max                 , 1)
    121     END_E_VALUE
    122 
    123     LOL_DECLARE_ENUM_METHODS(TexCoordBuildType)
    124 };
    125 
    126 LOL_SAFE_ENUM(MeshFaceType,
    127     BoxFront    = 0,
    128     QuadDefault = 0,
    129     BoxLeft     = 1,
    130     BoxBack     = 2,
    131     BoxRight    = 3,
    132     BoxTop      = 4,
    133     BoxBottom   = 5,
    134 
    135     Max
    136 );
    137 
    138 LOL_SAFE_ENUM(TexCoordPos,
    139     BL, // Bottom Left
    140     BR, // Bottom Right
    141     TL, // Top Left
    142     TR  // Top Right
    143 );
     199        Max
     200    };
     201protected:
     202    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     203    {
     204        enum_map[TriangleDefault] = "TriangleDefault";
     205        enum_map[QuadDefault] = "QuadDefault";
     206        enum_map[BoxDefault] = "BoxDefault";
     207        enum_map[SphereDefault] = "SphereDefault";
     208        enum_map[CapsuleDefault] = "CapsuleDefault";
     209        enum_map[TorusDefault] = "TorusDefault";
     210        enum_map[CylinderDefault] = "CylinderDefault";
     211        enum_map[DiscDefault] = "DiscDefault";
     212        enum_map[StarDefault] = "StarDefault";
     213        enum_map[ExpandedStarDefault] = "ExpandedStarDefault";
     214        enum_map[CogDefault] = "CogDefault";
     215        enum_map[Max] = "Max";
     216        return true;
     217    }
     218};
     219typedef SafeEnum<TexCoordBuildTypeBase> TexCoordBuildType;
     220
     221//MeshFaceType ----------------------------------------------------------------
     222struct MeshFaceTypeBase : public StructSafeEnum
     223{
     224    enum Type
     225    {
     226        BoxFront = 0,
     227        QuadDefault = 0,
     228        BoxLeft = 1,
     229        BoxBack = 2,
     230        BoxRight = 3,
     231        BoxTop = 4,
     232        BoxBottom = 5,
     233
     234        MAX
     235    };
     236protected:
     237    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     238    {
     239        enum_map[BoxFront] = "BoxFront";
     240        enum_map[QuadDefault] = "QuadDefault";
     241        enum_map[BoxLeft] = "BoxLeft";
     242        enum_map[BoxBack] = "BoxBack";
     243        enum_map[BoxRight] = "BoxRight";
     244        enum_map[BoxTop] = "BoxTop";
     245        enum_map[BoxBottom] = "BoxBottom";
     246        enum_map[MAX] = "MAX";
     247        return true;
     248    }
     249};
     250typedef SafeEnum<MeshFaceTypeBase> MeshFaceType;
     251
     252//TexCoordPos -----------------------------------------------------------------
     253struct TexCoordPosBase : public StructSafeEnum
     254{
     255    enum Type
     256    {
     257        BL, // Bottom Left
     258        BR, // Bottom Right
     259        TL, // Top Left
     260        TR  // Top Right
     261    };
     262protected:
     263    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     264    {
     265        enum_map[BL] = "BL";
     266        enum_map[BR] = "BR";
     267        enum_map[TL] = "TL";
     268        enum_map[TR] = "TR";
     269        return true;
     270    }
     271};
     272typedef SafeEnum<TexCoordPosBase> TexCoordPos;
    144273
    145274class EasyMeshBuildData
     
    176305
    177306    //UV1
    178     void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type[mt.ToScalar()] & 1); }
     307    void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt.ToScalar()] = (1 << (tcbt.ToScalar() + 1)) | (m_texcoord_build_type[mt.ToScalar()] & 1); }
    179308    TexCoordBuildType GetTexCoordBuildType(MeshType mt)
    180309    {
     
    264393
    265394    // UV2
    266     void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type2[mt.ToScalar()] & 1); }
     395    void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt.ToScalar()] = (1 << (tcbt.ToScalar() + 1)) | (m_texcoord_build_type2[mt.ToScalar()] & 1); }
    267396    TexCoordBuildType GetTexCoordBuildType2(MeshType mt)
    268397    {
     
    349478    }
    350479
    351     inline bool IsEnabled(MeshBuildOperation mbo) { return (m_build_flags & mbo) != 0; }
    352     inline void Enable(MeshBuildOperation mbo) { m_build_flags |= mbo; }
    353     inline void Disable(MeshBuildOperation mbo) { m_build_flags &= ~mbo; }
    354     inline void Toggle(MeshBuildOperation mbo) { m_build_flags ^= mbo; }
     480    inline bool IsEnabled(MeshBuildOperation mbo) { return (m_build_flags & mbo.ToScalar()) != 0; }
     481    inline void Enable(MeshBuildOperation mbo) { m_build_flags |= mbo.ToScalar(); }
     482    inline void Disable(MeshBuildOperation mbo) { m_build_flags &= ~mbo.ToScalar(); }
     483    inline void Toggle(MeshBuildOperation mbo) { m_build_flags ^= mbo.ToScalar(); }
    355484    inline void Set(MeshBuildOperation mbo, bool value) { if (value) Enable(mbo); else Disable(mbo); }
    356485
     
    373502};
    374503
    375 /* A safe enum for VertexDictionnary operations. */
    376 struct VDictType
    377 {
    378     DEF_VALUE
    379         ADD_VALUE_SET(DoesNotExist  , -3)
    380         ADD_VALUE_SET(Alone         , -2)
    381         ADD_VALUE_SET(Master        , -1)
    382     END_E_VALUE
    383 
    384     LOL_DECLARE_ENUM_METHODS(VDictType)
    385 };
     504//VDictType -- A safe enum for VertexDictionnary operations. ------------------
     505struct VDictTypeBase : public StructSafeEnum
     506{
     507    enum Type
     508    {
     509        DoesNotExist = -3,
     510        Alone = -2,
     511        Master = -1,
     512    };
     513protected:
     514    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     515    {
     516        enum_map[DoesNotExist] = "DoesNotExist";
     517        enum_map[Alone] = "Alone";
     518        enum_map[Master] = "Master";
     519        return true;
     520    }
     521};
     522typedef SafeEnum<VDictTypeBase> VDictType;
    386523
    387524/* TODO : replace VDict by a proper Half-edge system */
  • trunk/src/easymesh/easymeshrender.h

    r3580 r3816  
    2121{
    2222
    23 // Utility enum for renderers
    24 LOL_SAFE_ENUM(MeshRender,
    25     NeedData,
    26     NeedConvert,
    27     CanRender,
    28     IgnoreRender,
    29 );
     23//MeshRenderBase --------------------------------------------------------------
     24//Utility enum for renderers
     25struct MeshRenderBase : public StructSafeEnum
     26{
     27    enum Type
     28    {
     29        NeedData,
     30        NeedConvert,
     31        CanRender,
     32        IgnoreRender,
     33    };
     34protected:
     35    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     36    {
     37        enum_map[NeedData] = "NeedData";
     38        enum_map[NeedConvert] = "NeedConvert";
     39        enum_map[CanRender] = "CanRender";
     40        enum_map[IgnoreRender] = "IgnoreRender";
     41        return true;
     42    }
     43};
     44typedef SafeEnum<MeshRenderBase> MeshRender;
    3045
    3146//Vertex datas for easymesh vertex list.
  • trunk/src/lol/base/enum.h

    r3768 r3816  
    1919{
    2020
    21 extern map<int64_t, String> BuildEnumMap(char const *str, char const **custom);
     21////MyType --------------------------------------------------------------------
     22//struct MyTypeBase : public StructSafeEnum
     23//{
     24//    enum Type
     25//    {
     26//    };
     27//protected:
     28//    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     29//    {
     30//        enum_map[] = "";
     31//        return true;
     32//    }
     33//};
     34//typedef SafeEnum<MyTypeBase> MyType;
    2235
    23 class Enum
     36//-----------------------------------------------------------------------------
     37struct StructSafeEnum
    2438{
    25 public:
    26     template<typename T>
    27     static String EnumToString(T const& parameter)
    28     {
    29         UNUSED(parameter);
    30         // Create your own
    31         ASSERT(0);
    32         return String();
    33     }
     39protected:
     40    /* Convert to string stuff */
     41    virtual bool BuildEnumMap(map<int64_t, String>& enum_map) { return false; }
    3442};
    35 
     43//-----------------------------------------------------------------------------
    3644template<typename BASE, typename T = typename BASE::Type>
    3745class SafeEnum : public BASE
     
    4856    inline Type ToScalar() const { return m_value; }
    4957
    50     /* Convert to string description */
    51     inline class String ToString() const
     58        /* Convert to string stuff */
     59    inline class String ToString()
    5260    {
    5361        /* FIXME: we all know this isn’t thread safe. But is it really
     
    5664        static bool ready = false;
    5765
    58         if (!ready)
    59             enum_map = BuildEnumMap(BASE::GetDescription(), BASE::GetCustomString());
    60         ready = true;
    61 
    62         if (enum_map.has_key((int64_t)m_value))
    63             return enum_map[(int64_t)m_value];
     66                if (ready || BuildEnumMap(enum_map))
     67                {
     68                        ready = true;
     69                        if (enum_map.has_key((int64_t)m_value))
     70                                return enum_map[(int64_t)m_value];
     71                }
    6472        return "<invalid enum>";
    6573    }
     
    92100};
    93101
    94 #define LOL_OPEN_SAFE_ENUM(name, ...) \
    95     struct name ## Base \
    96     { \
    97         enum Type {__VA_ARGS__}; \
    98     protected: \
    99         static inline char const *GetDescription() { return #__VA_ARGS__; }
    100 #define LOL_SAFE_ENUM_CUSTOM_TOSTRING(...) \
    101         static inline char const **GetCustomString() \
    102         { \
    103             static char const *custom_list[] = { __VA_ARGS__ }; \
    104             return &custom_list[0]; \
    105         }
    106 #define LOL_CLOSE_SAFE_ENUM(name) \
    107     }; \
    108     typedef SafeEnum<name ## Base> name;
    109 
    110 #define LOL_SAFE_ENUM(name, ...) \
    111     struct name ## Base \
    112     { \
    113         enum Type {__VA_ARGS__}; \
    114     protected: \
    115         static inline char const *GetDescription()      { return #__VA_ARGS__; } \
    116         static inline char const **GetCustomString()    { return nullptr; } \
    117     }; \
    118     typedef SafeEnum<name ## Base> name;
    119 
    120 //-- STRUCT TEMPLATE:
    121 // enum E {
    122 //    DEF_VALUE
    123 //        ADD_VALUE(NEW_VALUE)
    124 //        ADD_VALUE_SET(NEW_VALUE, VALUE_SET)
    125 //    END_E_VALUE
    126 //    DEF_TEXT
    127 //        ADD_TEXT(NEW_VALUE)
    128 //    END_TEXT
    129 //    LOL_DECLARE_ENUM_METHODS(E)
    130 // };
    131 
    132 #define LOL_DECLARE_ENUM_METHODS(E) \
    133     inline E()                       : m_value(MAX) {}           \
    134     inline E(Value v)                : m_value(v) {}             \
    135     inline E(const int8_t    & v)    : m_value((Value)v) {}      \
    136     inline E(const int16_t   & v)    : m_value((Value)v) {}      \
    137     inline E(const int32_t   & v)    : m_value((Value)v) {}      \
    138     inline E(const int64_t   & v)    : m_value((Value)v) {}      \
    139     inline E(const uint8_t   & v)    : m_value((Value)v) {}      \
    140     inline E(const uint16_t  & v)    : m_value((Value)v) {}      \
    141     inline E(const uint32_t  & v)    : m_value((Value)v) {}      \
    142     inline E(const uint64_t  & v)    : m_value((Value)v) {}      \
    143     inline operator Value() { return m_value; } \
    144     inline int32_t  I()     { return (int32_t ) m_value; } \
    145     inline int8_t   I8()    { return (int8_t  ) m_value; } \
    146     inline int16_t  I16()   { return (int16_t ) m_value; } \
    147     inline int32_t  I32()   { return (int32_t ) m_value; } \
    148     inline int64_t  I64()   { return (int64_t ) m_value; } \
    149     inline uint32_t UI()    { return (uint32_t) m_value; } \
    150     inline uint8_t  UI8()   { return (uint8_t ) m_value; } \
    151     inline uint16_t UI16()  { return (uint16_t) m_value; } \
    152     inline uint32_t UI32()  { return (uint32_t) m_value; } \
    153     inline uint64_t UI64()  { return (uint64_t) m_value; } \
    154     bool operator==(const E & v) { return m_value == v.m_value; } \
    155     bool operator!=(const E & v) { return m_value != v.m_value; } \
    156     bool operator<(const E & v)  { return m_value < v.m_value; }  \
    157     bool operator>(const E & v)  { return m_value > v.m_value; }  \
    158     bool operator<=(const E & v) { return m_value <= v.m_value; } \
    159     bool operator>=(const E & v) { return m_value >= v.m_value; }
    160 
    161 #define DEF_VALUE                           enum Value { INVALID = -1,
    162 #define ADD_VALUE(NEW_VALUE)                NEW_VALUE,
    163 #define ADD_VALUE_SET(NEW_VALUE, VALUE_SET) NEW_VALUE = VALUE_SET,
    164 #define END_E_VALUE                         MAX } m_value;
    165 
    166 #define DEF_TEXT \
    167     inline String C() \
    168     { \
    169         static const String text[] = {
    170 
    171 #define ADD_TEXT(NEW_TEXT) String(#NEW_TEXT),
    172 #define ADD_TEXT_PADDING   String(""),
    173 
    174 #define END_TEXT \
    175         }; \
    176         if (m_value < 0 || m_value >= MAX) \
    177             return "INVALID"; \
    178         return text[m_value]; \
    179     };
    180 
    181102} /* namespace lol */
    182103
  • trunk/src/lol/gpu/shader.h

    r3762 r3816  
    3434 * we can always reorganise the vertex declaration for the indices to
    3535 * match. If the need arises these enums will be added. */
    36 LOL_SAFE_ENUM(VertexUsage,
    37     Position,
    38     BlendWeight,
    39     BlendIndices,
    40     Normal,
    41     PointSize,
    42     TexCoord,
    43     TexCoordExt,
    44     Tangent,
    45     Binormal,
    46     TessFactor,
    47     PositionT,
    48     Color,
    49     Fog,
    50     Depth,
    51     Sample,
    52     MAX,
    53 );
    54 
    55 //Enum definitions ------------------------------------------------------------
     36//VertexUsageBase -------------------------------------------------------------
     37struct VertexUsageBase : public StructSafeEnum
     38{
     39
     40    enum Type
     41    {
     42        Position,
     43        BlendWeight,
     44        BlendIndices,
     45        Normal,
     46        PointSize,
     47        TexCoord,
     48        TexCoordExt,
     49        Tangent,
     50        Binormal,
     51        TessFactor,
     52        PositionT,
     53        Color,
     54        Fog,
     55        Depth,
     56        Sample,
     57        MAX,
     58    };
     59protected:
     60    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     61    {
     62        enum_map[Position] = "Position";
     63        enum_map[BlendWeight] = "BlendWeight";
     64        enum_map[BlendIndices] = "BlendIndices";
     65        enum_map[Normal] = "Normal";
     66        enum_map[PointSize] = "PointSize";
     67        enum_map[TexCoord] = "TexCoord";
     68        enum_map[TexCoordExt] = "TexCoordExt";
     69        enum_map[Tangent] = "Tangent";
     70        enum_map[Binormal] = "Binormal";
     71        enum_map[TessFactor] = "TessFactor";
     72        enum_map[PositionT] = "PositionT";
     73        enum_map[Color] = "Color";
     74        enum_map[Fog] = "Fog";
     75        enum_map[Depth] = "Depth";
     76        enum_map[Sample] = "Sample";
     77        enum_map[MAX] = "MAX";
     78        return true;
     79    }
     80};
     81typedef SafeEnum<VertexUsageBase> VertexUsage;
     82
     83//-----------------------------------------------------------------------------
     84//Enum definitions
     85//-----------------------------------------------------------------------------
     86//ShaderVariableBase ----------------------------------------------------------
    5687struct ShaderVariableBase
    5788{
     
    69100    };
    70101protected:
    71     static inline char const *GetDescription()      { return nullptr; }
    72     static inline char const **GetCustomString()    { return nullptr; }
     102    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     103    {
     104        enum_map[Attribute] = "Attribute";
     105        enum_map[Uniform] = "Uniform";
     106        enum_map[Varying] = "Varying";
     107        enum_map[InOut] = "InOut";
     108        enum_map[MAX] = "MAX";
     109        return true;
     110    }
    73111};
    74112typedef SafeEnum<ShaderVariableBase> ShaderVariable;
    75113
     114//ShaderProgramBase -----------------------------------------------------------
    76115struct ShaderProgramBase
    77116{
     
    85124    };
    86125protected:
    87     static inline char const *GetDescription()      { return nullptr; }
    88     static inline char const **GetCustomString()    { return nullptr; }
     126    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     127    {
     128        enum_map[Geometry] = "Geometry";
     129        enum_map[Vertex] = "Vertex";
     130        enum_map[Pixel] = "Pixel";
     131        enum_map[MAX] = "MAX";
     132        return true;
     133    }
    89134};
    90135typedef SafeEnum<ShaderProgramBase> ShaderProgram;
  • trunk/src/lol/gpu/vertexbuffer.h

    r3580 r3816  
    4040/* A safe enum to indicate what kind of primitive to draw. Used in
    4141 * VertexDeclaration::DrawElements() for instance. */
    42 LOL_SAFE_ENUM(MeshPrimitive,
    43     Triangles,
    44     TriangleStrips,
    45     TriangleFans,
    46     Points,
    47     Lines,
    48 );
     42//MeshPrimitiveBase -- A safe enum for Primitive edge face. -------------------
     43struct MeshPrimitiveBase : public StructSafeEnum
     44{
     45    enum Type
     46    {
     47        Triangles,
     48        TriangleStrips,
     49        TriangleFans,
     50        Points,
     51        Lines,
     52    };
     53protected:
     54    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     55    {
     56        enum_map[Triangles]      = "Triangles";
     57        enum_map[TriangleStrips] = "TriangleStrips";
     58        enum_map[TriangleFans]   = "TriangleFans";
     59        enum_map[Points]         = "Points";
     60        enum_map[Lines]          = "Lines";
     61        return true;
     62    }
     63};
     64typedef SafeEnum<MeshPrimitiveBase> MeshPrimitive;
    4965
    5066class VertexStreamBase
  • trunk/src/lol/math/geometry.h

    r3798 r3816  
    2828
    2929//AxisBase --------------------------------------------------------------------
    30 struct AxisBase
     30    struct AxisBase : public StructSafeEnum
    3131{
    3232    enum Type
     
    3535    };
    3636protected:
    37     static inline char const *GetDescription()      { return "X,Y,Z,MAX,XY,XYZ"; }
    38     static inline char const **GetCustomString()    { return nullptr; }
     37        virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     38        {
     39                enum_map[X]   = "X";
     40                enum_map[Y]   = "Y";
     41                enum_map[Z]   = "Z";
     42        enum_map[MAX] = "MAX";
     43                enum_map[XY]  = "XY";
     44                enum_map[XYZ] = "XYZ";
     45                return true;
     46        }
    3947};
    4048typedef SafeEnum<AxisBase> Axis;
    4149
    4250//DirectionBase ---------------------------------------------------------------
    43 struct DirectionBase
     51struct DirectionBase : public StructSafeEnum
    4452{
    4553    enum Type
     
    4856    };
    4957protected:
    50     static inline char const *GetDescription()      { return "Up,Down,Left,Right,MAX"; }
    51     static inline char const **GetCustomString()    { return nullptr; }
     58        virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     59        {
     60                enum_map[Up]    = "Up";
     61                enum_map[Down]  = "Down";
     62                enum_map[Left]  = "Left";
     63                enum_map[Right] = "Right";
     64        enum_map[MAX]   = "MAX";
     65                return true;
     66        }
    5267};
    5368typedef SafeEnum<DirectionBase> Direction;
     
    266281                      vec3 &vi);
    267282
    268 struct RayIntersect
    269 {
    270     DEF_VALUE
    271         ADD_VALUE(Nothing)
    272         ADD_VALUE(All)
    273         ADD_VALUE(None)
    274         ADD_VALUE(P0)
    275         ADD_VALUE(P1)
    276     END_E_VALUE
    277 
    278     LOL_DECLARE_ENUM_METHODS(RayIntersect)
    279 };
     283//RayIntersect ----------------------------------------------------------------
     284struct RayIntersectBase : public StructSafeEnum
     285{
     286    enum Type
     287    {
     288        Nothing,
     289        All,
     290        None,
     291        P0,
     292        P1,
     293    };
     294    //LOL_DECLARE_ENUM_METHODS(RayIntersectBase)
     295protected:
     296    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     297    {
     298        enum_map[Nothing] = "Nothing";
     299        enum_map[All] = "All";
     300        enum_map[None] = "None";
     301        enum_map[P0] = "P0";
     302        enum_map[P1] = "P1";
     303        return true;
     304    }
     305};
     306typedef SafeEnum<RayIntersectBase> RayIntersect;
    280307
    281308#define RAY_ISECT_NOTHING   0
     
    323350}
    324351
    325 /* A safe enum for Primitive edge face. */
    326 LOL_SAFE_ENUM(PlaneIntersection,
    327     Back,
    328     Front,
    329     Plane,
    330 );
     352//PlaneIntersectionBase -------------------------------------------------------
     353struct PlaneIntersectionBase : public StructSafeEnum
     354{
     355    /* A safe enum for Primitive edge face. */
     356    enum Type
     357    {
     358        Back, Front, Plane,
     359    };
     360protected:
     361    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     362    {
     363        enum_map[Back]  = "Back";
     364        enum_map[Front] = "Front";
     365        enum_map[Plane] = "Plane";
     366        return true;
     367    }
     368};
     369typedef SafeEnum<PlaneIntersectionBase> PlaneIntersection;
    331370
    332371//Point/Plane : Normal must be given normalized.
  • trunk/src/lol/sys/file.h

    r3580 r3816  
    2121{
    2222
    23 LOL_SAFE_ENUM(FileAccess,
    24     Read = 0,
    25     Write
    26 );
     23//FileAccessBase --------------------------------------------------------------
     24struct FileAccessBase : public StructSafeEnum
     25{
     26    enum Type
     27    {
     28        Read = 0,
     29        Write
     30    };
     31protected:
     32    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     33    {
     34        enum_map[Read]  = "Read";
     35        enum_map[Write] = "Write";
     36        return true;
     37    }
     38};
     39typedef SafeEnum<FileAccessBase> FileAccess;
    2740
    28 LOL_SAFE_ENUM(StreamType,
    29     StdIn,
    30     StdOut,
    31     StdErr,
    32     File,
    33     FileBinary
    34 );
     41//StreamTypeBase --------------------------------------------------------------
     42struct StreamTypeBase : public StructSafeEnum
     43{
     44    enum Type
     45    {
     46        StdIn,
     47        StdOut,
     48        StdErr,
     49        File,
     50        FileBinary
     51    };
     52protected:
     53    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     54    {
     55        enum_map[StdIn]      = "StdIn";
     56        enum_map[StdOut]     = "StdOut";
     57        enum_map[StdErr]     = "StdErr";
     58        enum_map[File]       = "File";
     59        enum_map[FileBinary] = "FileBinary";
     60        return true;
     61    }
     62};
     63typedef SafeEnum<StreamTypeBase> StreamType;
    3564
    3665class File
  • trunk/src/lol/sys/thread.h

    r3776 r3816  
    4747};
    4848
    49 struct ThreadStatus
     49//ThreadStatus ----------------------------------------------------------------
     50struct ThreadStatusBase : public StructSafeEnum
    5051{
    51     DEF_VALUE
    52         ADD_VALUE(NOTHING)
    53         ADD_VALUE(THREAD_STARTED)
    54         ADD_VALUE(THREAD_STOPPED)
    55     END_E_VALUE
     52    enum Type
     53    {
     54        NOTHING,
     55        THREAD_STARTED,
     56        THREAD_STOPPED,
     57    };
     58protected:
     59    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     60    {
     61        enum_map[NOTHING] = "NOTHING";
     62        enum_map[THREAD_STARTED] = "THREAD_STARTED";
     63        enum_map[THREAD_STOPPED] = "THREAD_STOPPED";
     64        return true;
     65    }
     66};
     67typedef SafeEnum<ThreadStatusBase> ThreadStatus;
    5668
    57     LOL_DECLARE_ENUM_METHODS(ThreadStatus)
     69struct ThreadJobTypeBase : public StructSafeEnum
     70{
     71    enum Type
     72    {
     73        NONE,
     74        WORK_TODO,
     75        WORK_DONE,
     76        WORK_FAILED,
     77        WORK_FETCHED,
     78        THREAD_STOP
     79    };
     80protected:
     81    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     82    {
     83        enum_map[NONE]         = "NONE";
     84        enum_map[WORK_TODO]    = "WORK_TODO";
     85        enum_map[WORK_DONE]    = "WORK_DONE";
     86        enum_map[WORK_FAILED]  = "WORK_FAILED";
     87        enum_map[WORK_FETCHED] = "WORK_FETCHED";
     88        enum_map[THREAD_STOP]  = "THREAD_STOP";
     89        return true;
     90    }
    5891};
    59 
    60 LOL_SAFE_ENUM(ThreadJobType,
    61     NONE,
    62     WORK_TODO,
    63     WORK_DONE,
    64     WORK_FAILED,
    65     WORK_FETCHED,
    66     THREAD_STOP
    67 );
     92typedef SafeEnum<ThreadJobTypeBase> ThreadJobType;
    6893
    6994class ThreadJob
  • trunk/src/messageservice.cpp

    r3577 r3816  
    6464    if (g_messageservice)
    6565    {
    66         ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
     66        ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count());
    6767        return g_messageservice->Send(id, message.C());
    6868    }
     
    7474    if (g_messageservice)
    7575    {
    76         ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
     76        ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count());
    7777        MessageService& g = *g_messageservice;
    78         array<MessageList>& bucket = g.m_bucket[id];
     78        array<MessageList>& bucket = g.m_bucket[id.ToScalar()];
    7979        bucket << MessageList(time(nullptr), String(message));
    8080        return true;
     
    8888    if (g_messageservice)
    8989    {
    90         ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
     90        ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count());
    9191        time_t timestamp;
    9292        return g_messageservice->FetchFirst(id, message, timestamp);
     
    9999    if (g_messageservice)
    100100    {
    101         ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
     101        ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count());
    102102        MessageService& g = *g_messageservice;
    103         array<MessageList>& bucket = g.m_bucket[id];
     103        array<MessageList>& bucket = g.m_bucket[id.ToScalar()];
    104104
    105105        if (bucket.Count())
     
    119119    if (g_messageservice)
    120120    {
    121         ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
     121        ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count());
    122122        time_t timestamp;
    123123        return g_messageservice->FetchAll(id, message, timestamp);
     
    130130    if (g_messageservice)
    131131    {
    132         ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
     132        ASSERT(0 <= id.ToScalar() && id.ToScalar() < g_messageservice->m_bucket.Count());
    133133        MessageService& g = *g_messageservice;
    134         array<MessageList>& bucket = g.m_bucket[id];
     134        array<MessageList>& bucket = g.m_bucket[id.ToScalar()];
    135135        message = String("");
    136136
  • trunk/src/messageservice.h

    r3580 r3816  
    2020{
    2121
    22 // Utility enum for message service
    23 struct MessageBucket
     22//MessageBucket -- Utility enum for message service ---------------------------
     23struct MessageBucketBase : public StructSafeEnum
    2424{
    25     DEF_VALUE
    26         ADD_VALUE(AppIn)
    27         ADD_VALUE(AppOut)
     25    enum Type
     26    {
     27        AppIn,
     28        AppOut,
    2829
    29         ADD_VALUE(Bckt0)
    30         ADD_VALUE(Bckt1)
    31         ADD_VALUE(Bckt2)
    32         ADD_VALUE(Bckt3)
    33         ADD_VALUE(Bckt4)
    34         ADD_VALUE(Bckt5)
    35         ADD_VALUE(Bckt6)
    36         ADD_VALUE(Bckt7)
    37         ADD_VALUE(Bckt8)
    38         ADD_VALUE(Bckt9)
    39     END_E_VALUE
     30        Bckt0,
     31        Bckt1,
     32        Bckt2,
     33        Bckt3,
     34        Bckt4,
     35        Bckt5,
     36        Bckt6,
     37        Bckt7,
     38        Bckt8,
     39        Bckt9,
    4040
    41     LOL_DECLARE_ENUM_METHODS(MessageBucket)
     41        MAX
     42    };
     43protected:
     44    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     45    {
     46        enum_map[AppIn] = "AppIn";
     47        enum_map[AppOut] = "AppOut";
     48        enum_map[Bckt0] = "Bckt0";
     49        enum_map[Bckt1] = "Bckt1";
     50        enum_map[Bckt2] = "Bckt2";
     51        enum_map[Bckt3] = "Bckt3";
     52        enum_map[Bckt4] = "Bckt4";
     53        enum_map[Bckt5] = "Bckt5";
     54        enum_map[Bckt6] = "Bckt6";
     55        enum_map[Bckt7] = "Bckt7";
     56        enum_map[Bckt8] = "Bckt8";
     57        enum_map[Bckt9] = "Bckt9";
     58        enum_map[MAX] = "MAX";
     59        return true;
     60    }
    4261};
     62typedef SafeEnum<MessageBucketBase> MessageBucket;
    4363
    4464//Message list container with time in it
  • trunk/src/t/base/enum.cpp

    r3577 r3816  
    2424    lolunit_declare_test(EnumToString)
    2525    {
    26         LOL_SAFE_ENUM(MyEnum,
    27             First = -10,
    28             Second,
    29             Third = 5,
    30         );
     26        struct MyEnumBase : public StructSafeEnum
     27        {
     28            enum Type
     29            {
     30                First = -10,
     31                Second,
     32                Third = 5,
     33            };
     34        protected:
     35            virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     36            {
     37                enum_map[First] = "First";
     38                enum_map[Second] = "Second";
     39                enum_map[Third] = "Third";
     40                return true;
     41            }
     42        };
     43        typedef SafeEnum<MyEnumBase> MyEnum;
    3144
    3245        MyEnum e = MyEnum::First;
  • trunk/src/utils.h

    r3780 r3816  
    6161}
    6262
    63 // Gets the value for the given LOL_SAFE_ENUM type.
     63// Gets the value for the given enum type.
    6464template<class T> inline T FindValue(const char* name)
    6565{
Note: See TracChangeset for help on using the changeset viewer.