lolengine
/
lol
镜像来自 https://github.com/lolengine/lol
1
0
複製 0
程式碼 問題 0 版本發佈 0 Wiki 活動
瀏覽代碼

base: make the safe enums slightly safer. :-)

undefined
Sam Hocevar 11 年之前
父節點
231d74f1f8
當前提交
7e769d6c79
共有 19 個檔案被更改，包括 358 行新增 和 324 行删除
分割檢視
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -0
      src/Makefile.am
  2. +7
    -4
      src/commandstack.h
  3. +14
    -14
      src/easymesh/easymesh.cpp
  4. +34
    -25
      src/easymesh/easymesh.h
  5. +92
    -71
      src/easymesh/easymeshbuild.h
  6. +11
    -8
      src/easymesh/easymeshrender.h
  7. +1
    -1
      src/gpu/shader.cpp
  8. +1
    -0
      src/lol/base/all.h
  9. +121
    -0
      src/lol/base/enum.h
  10. +0
    -155
      src/lol/base/types.h
  11. +7
    -2
      src/lol/gpu/shader.h
  12. +10
    -4
      src/lol/math/geometry.h
  13. +22
    -16
      src/lol/sys/file.h
  14. +18
    -12
      src/lol/sys/thread.h
  15. +2
    -1
      src/lolcore.vcxproj
  16. +4
    -1
      src/lolcore.vcxproj.filters
  17. +6
    -6
      src/messageservice.cpp
  18. +6
    -3
      src/messageservice.h
  19. +1
    -1
      src/sys/file.cpp

+ 1
- 0
src/Makefile.am 查看文件

@@ -35,6 +35,7 @@ liblolcore_headers = \
lol/base/all.h \
lol/base/log.h lol/base/array.h lol/base/types.h lol/base/array.h \
lol/base/assert.h lol/base/string.h lol/base/hash.h lol/base/map.h \
lol/base/enum.h \
\
lol/math/all.h \
lol/math/functions.h lol/math/vector.h lol/math/half.h lol/math/real.h \


+ 7
- 4
src/commandstack.h 查看文件

@@ -56,7 +56,7 @@ public:
inline ivec3 IV3() { ivec3 v(IV2(), 0); v.z = I(); return v; }
inline ivec4 IV4() { ivec4 v(IV3(), 0); v.w = I(); return v; }

//Alternate getters
// Alternate getters
inline void GetValue(float &f) { f = F(); }
inline void GetValue(int &i) { i = I(); }
inline void GetValue(bool &b) { b = B(); }
@@ -66,9 +66,9 @@ public:
inline void GetValue(ivec2 &iv2) { iv2 = IV2(); }
inline void GetValue(ivec3 &iv3) { iv3 = IV3(); }
inline void GetValue(ivec4 &iv4) { iv4 = IV4(); }
//For Safe Enum
template< class T > inline
void GetValue(T &i) { i = T((typename T::Value)I()); }
// For Safe Enum
template<class DEF> inline
void GetValue(SafeEnum<DEF> &i) { i = typename DEF::Type(I()); }

//SETTER
CommandStack &operator<<(int i) { m_ints << i; return *this; }
@@ -80,6 +80,9 @@ public:
CommandStack &operator<<(ivec2 iv) { return (*this << iv.x << iv.y); }
CommandStack &operator<<(ivec3 iv) { return (*this << iv.xy << iv.z); }
CommandStack &operator<<(ivec4 iv) { return (*this << iv.xyz << iv.w); }
// For Safe Enum
template<class DEF> inline
CommandStack &operator<<(SafeEnum<DEF> &i) { return *this << i.ToScalar(); }
};

} /* namespace lol */


+ 14
- 14
src/easymesh/easymesh.cpp 查看文件

@@ -1201,41 +1201,41 @@ void EasyMesh::DoMeshTransform(MeshTransform ct, Axis axis0, Axis axis1, float n

for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
{
switch (ct)
switch (ct.ToScalar())
{
case MeshTransform::Taper:
{
float value = m_vert[i].m_coord[axis0];
float value = m_vert[i].m_coord[axis0.ToScalar()];
if (absolute) value = abs(value);
m_vert[i].m_coord[(axis0 + 1) % 3] *= max(0.f, 1.f + (n0 * value + noff));
m_vert[i].m_coord[(axis0 + 2) % 3] *= max(0.f, 1.f + (n1 * value + noff));
m_vert[i].m_coord[(axis0.ToScalar() + 1) % 3] *= max(0.f, 1.f + (n0 * value + noff));
m_vert[i].m_coord[(axis0.ToScalar() + 2) % 3] *= max(0.f, 1.f + (n1 * value + noff));
break;
}
case MeshTransform::Twist:
{
vec3 rotaxis = vec3(1.f); rotaxis[(axis0 + 1) % 3] = .0f; rotaxis[(axis0 + 2) % 3] = .0f;
m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0] * n0 + noff, rotaxis) * m_vert[i].m_coord;
vec3 rotaxis = vec3(1.f); rotaxis[(axis0.ToScalar() + 1) % 3] = .0f; rotaxis[(axis0.ToScalar() + 2) % 3] = .0f;
m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0.ToScalar()] * n0 + noff, rotaxis) * m_vert[i].m_coord;
break;
}
case MeshTransform::Shear:
{
float value = m_vert[i].m_coord[axis0];
float value = m_vert[i].m_coord[axis0.ToScalar()];
if (absolute) value = abs(value);
m_vert[i].m_coord[(axis0 + 1) % 3] += (n0 * value + noff);
m_vert[i].m_coord[(axis0 + 2) % 3] += (n1 * value + noff);
m_vert[i].m_coord[(axis0.ToScalar() + 1) % 3] += (n0 * value + noff);
m_vert[i].m_coord[(axis0.ToScalar() + 2) % 3] += (n1 * value + noff);
break;
}
case MeshTransform::Stretch:
{
//float value = abs(m_vert[i].m1[axis0]);
//m_vert[i].m1[(axis0 + 1) % 3] += (lol::pow(value, n0) + noff);
//m_vert[i].m1[(axis0 + 2) % 3] += (lol::pow(value, n1) + noff);
//float value = abs(m_vert[i].m1[axis0.ToScalar()]);
//m_vert[i].m1[(axis0.ToScalar() + 1) % 3] += (lol::pow(value, n0) + noff);
//m_vert[i].m1[(axis0.ToScalar() + 2) % 3] += (lol::pow(value, n1) + noff);
break;
}
case MeshTransform::Bend:
{
vec3 rotaxis = vec3(1.f); rotaxis[(axis1 + 1) % 3] = .0f; rotaxis[(axis1 + 2) % 3] = .0f;
m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0] * n0 + noff, rotaxis) * m_vert[i].m_coord;
vec3 rotaxis = vec3(1.f); rotaxis[(axis1.ToScalar() + 1) % 3] = .0f; rotaxis[(axis1.ToScalar() + 2) % 3] = .0f;
m_vert[i].m_coord = mat3::rotate(m_vert[i].m_coord[axis0.ToScalar()] * n0 + noff, rotaxis) * m_vert[i].m_coord;
break;
}
}


+ 34
- 25
src/easymesh/easymesh.h 查看文件

@@ -26,33 +26,42 @@ namespace lol
{

/* A safe enum for MeshCSG operations. */
DEF_ENUM(CSGUsage)
DEF_VALUE
ADD_VALUE(Union)
ADD_VALUE(Substract)
ADD_VALUE(SubstractLoss) //will remove B from A, but not add inverted B
ADD_VALUE(And)
ADD_VALUE(Xor)
END_E_VALUE
END_ENUM(CSGUsage)
struct CSGUsageDef
{
enum Type
{
Union,
Substract,
SubstractLoss, //will remove B from A, but not add inverted B
And,
Xor,
};
};
typedef SafeEnum<CSGUsageDef> CSGUsage;

DEF_ENUM(Axis)
DEF_VALUE
ADD_VALUE(X)
ADD_VALUE(Y)
ADD_VALUE(Z)
END_E_VALUE
END_ENUM(Axis)
struct AxisDef
{
enum Type
{
X,
Y,
Z,
};
};
typedef SafeEnum<AxisDef> Axis;

DEF_ENUM(MeshTransform)
DEF_VALUE
ADD_VALUE(Taper)
ADD_VALUE(Twist)
ADD_VALUE(Bend)
ADD_VALUE(Stretch)
ADD_VALUE(Shear)
END_E_VALUE
END_ENUM(MeshTransform)
struct MeshTransformDef
{
enum Type
{
Taper,
Twist,
Bend,
Stretch,
Shear,
};
};
typedef SafeEnum<MeshTransformDef> MeshTransform;

class EasyMesh
{


+ 92
- 71
src/easymesh/easymeshbuild.h 查看文件

@@ -21,7 +21,8 @@
namespace lol
{

DEF_ENUM(MeshBuildOperation)
struct MeshBuildOperation
{
DEF_VALUE
//When this flag is up, negative scaling will not invert faces.
ADD_VALUE_SET(ScaleWinding , (1 << 0))
@@ -34,9 +35,12 @@ DEF_ENUM(MeshBuildOperation)

ADD_VALUE_SET(All , 0xffffffff)
END_E_VALUE
END_ENUM(MeshBuildOperation)

DEF_ENUM(EasyMeshCmdType)
LOL_DECLARE_ENUM_METHODS(MeshBuildOperation)
};

struct EasyMeshCmdType
{
DEF_VALUE
ADD_VALUE(MeshCsg)

@@ -78,26 +82,32 @@ DEF_ENUM(EasyMeshCmdType)
ADD_VALUE(AppendSimpleQuad)
ADD_VALUE(AppendCog)
END_E_VALUE
END_ENUM(EasyMeshCmdType)

DEF_ENUM(MeshType)
DEF_VALUE
ADD_VALUE(Triangle)
ADD_VALUE(Quad)
ADD_VALUE(Box)
ADD_VALUE(Sphere)
ADD_VALUE(Capsule)
ADD_VALUE(Torus)
ADD_VALUE(Cylinder)
ADD_VALUE(Disc)
ADD_VALUE(Star)
ADD_VALUE(ExpandedStar)
ADD_VALUE(Cog)
ADD_VALUE(NEW_VALUE)
END_E_VALUE
END_ENUM(MeshType)
LOL_DECLARE_ENUM_METHODS(EasyMeshCmdType)
};

DEF_ENUM(TexCoordBuildType)
struct MeshTypeDef
{
enum Type
{
Triangle,
Quad,
Box,
Sphere,
Capsule,
Torus,
Cylinder,
Disc,
Star,
ExpandedStar,
Cog,
MAX,
};
};
typedef SafeEnum<MeshTypeDef> MeshType;

struct TexCoordBuildType
{
DEF_VALUE
ADD_VALUE_SET(TriangleDefault , 0)
ADD_VALUE_SET(QuadDefault , 0)
@@ -114,31 +124,37 @@ DEF_ENUM(TexCoordBuildType)
//NEVER FORGET TO INCREMENT THIS WHEN ADDING A VALUE
ADD_VALUE_SET(Max , 1)
END_E_VALUE
END_ENUM(TexCoordBuildType)

DEF_ENUM(MeshFaceType)
DEF_VALUE
ADD_VALUE_SET(BoxFront , 0)
ADD_VALUE_SET(BoxLeft , 1)
ADD_VALUE_SET(BoxBack , 2)
ADD_VALUE_SET(BoxRight , 3)
ADD_VALUE_SET(BoxTop , 4)
ADD_VALUE_SET(BoxBottom , 5)
ADD_VALUE_SET(QuadDefault , 0)
LOL_DECLARE_ENUM_METHODS(TexCoordBuildType)
};

//NEVER FORGET TO INCREMENT THIS WHEN ADDING A VALUE
ADD_VALUE_SET(Max , 6)
END_E_VALUE
END_ENUM(MeshFaceType)
struct MeshFaceTypeDef
{
enum Type
{
BoxFront = 0,
QuadDefault = 0,
BoxLeft = 1,
BoxBack = 2,
BoxRight = 3,
BoxTop = 4,
BoxBottom = 5,
Max,
};
};
typedef SafeEnum<MeshFaceTypeDef> MeshFaceType;

DEF_ENUM(TexCoordPos)
DEF_VALUE
ADD_VALUE(BL) //BottomLeft
ADD_VALUE(BR) //BottomRight
ADD_VALUE(TL) //TopLeft
ADD_VALUE(TR) //TopRight
END_E_VALUE
END_ENUM(TexCoordPos)
struct TexCoordPosDef
{
enum Type
{
BL, //BottomLeft
BR, //BottomRight
TL, //TopLeft
TR, //TopRight
};
};
typedef SafeEnum<TexCoordPosDef> TexCoordPos;

class EasyMeshBuildData
{
@@ -173,10 +189,10 @@ public:
inline vec2 &TexCoordScale2() { return m_texcoord_scale2; }

//UV1
void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt] = (1 << (tcbt + 1)) | (m_texcoord_build_type[mt] & 1); }
void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type[mt.ToScalar()] & 1); }
TexCoordBuildType GetTexCoordBuildType(MeshType mt)
{
uint32_t flag = (uint32_t)((m_texcoord_build_type[mt] & ~(1)) >> 1);
uint32_t flag = (uint32_t)((m_texcoord_build_type[mt.ToScalar()] & ~(1)) >> 1);
int i = 0;
while (flag >>= 1)
i++;
@@ -184,22 +200,23 @@ public:
}
void SetTexCoordCustomBuild(MeshType mt, MeshFaceType face, vec2 BL, vec2 TR)
{
if (face >= m_texcoord_custom_build[mt].Count())
m_texcoord_custom_build[mt].Resize(face + 1);
m_texcoord_custom_build[mt][face].m1 = BL;
m_texcoord_custom_build[mt][face].m2 = TR;
m_texcoord_build_type[mt] |= 1;
if (face.ToScalar() >= m_texcoord_custom_build[mt.ToScalar()].Count())
m_texcoord_custom_build[mt.ToScalar()].Resize(face.ToScalar() + 1);
m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m1 = BL;
m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m2 = TR;
m_texcoord_build_type[mt.ToScalar()] |= 1;
}
void ClearTexCoordCustomBuild(MeshType mt) { m_texcoord_build_type[mt] &= ~1; }
void ClearTexCoordCustomBuild(MeshType mt) { m_texcoord_build_type[mt.ToScalar()] &= ~1; }
/* FIXME : Do something better ? */
vec2 TexCoord(MeshType mt, TexCoordPos tcp, MeshFaceType face)
{
vec2 BL = vec2(0.f);
vec2 TR = vec2(0.f);
if (m_texcoord_build_type[mt] & 1 && face < m_texcoord_custom_build[mt].Count())
if (m_texcoord_build_type[mt.ToScalar()] & 1
&& face.ToScalar() < m_texcoord_custom_build[mt.ToScalar()].Count())
{
BL = m_texcoord_custom_build[mt][face].m1;
TR = m_texcoord_custom_build[mt][face].m2;
BL = m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m1;
TR = m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m2;
}
else
{
@@ -225,8 +242,8 @@ public:
{ vec2(0.f, .5f), vec2(.5f, 1.f) },
{ vec2(.5f, .5f), vec2(1.f, 1.f) }
};
BL = data[face][0]; //[tcbt]
TR = data[face][1]; //[tcbt]
BL = data[face.ToScalar()][0]; //[tcbt]
TR = data[face.ToScalar()][1]; //[tcbt]
}
else if (mt == MeshType::Sphere)
mt = mt;
@@ -260,10 +277,10 @@ public:
}

//UV2
void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt] = (1 << (tcbt + 1)) | (m_texcoord_build_type2[mt] & 1); }
void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type2[mt.ToScalar()] & 1); }
TexCoordBuildType GetTexCoordBuildType2(MeshType mt)
{
uint32_t flag = ((m_texcoord_build_type2[mt] & ~(1)) >> 1);
uint32_t flag = ((m_texcoord_build_type2[mt.ToScalar()] & ~(1)) >> 1);
int i = 0;
while (flag >>= 1)
i++;
@@ -271,21 +288,22 @@ public:
}
void SetTexCoordCustomBuild2(MeshType mt, MeshFaceType face, vec2 BL, vec2 TR)
{
if (face >= m_texcoord_custom_build2[mt].Count())
m_texcoord_custom_build2[mt].Resize(face + 1);
m_texcoord_custom_build2[mt][face].m1 = BL;
m_texcoord_custom_build2[mt][face].m2 = TR;
m_texcoord_build_type2[mt] |= 1;
if (face.ToScalar() >= m_texcoord_custom_build2[mt.ToScalar()].Count())
m_texcoord_custom_build2[mt.ToScalar()].Resize(face.ToScalar() + 1);
m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m1 = BL;
m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m2 = TR;
m_texcoord_build_type2[mt.ToScalar()] |= 1;
}
void ClearTexCoordCustomBuild2(MeshType mt) { m_texcoord_build_type2[mt] &= ~1; }
void ClearTexCoordCustomBuild2(MeshType mt) { m_texcoord_build_type2[mt.ToScalar()] &= ~1; }
vec2 TexCoord2(MeshType mt, TexCoordPos tcp, MeshFaceType face)
{
vec2 BL = vec2(0.f);
vec2 TR = vec2(0.f);
if (m_texcoord_build_type2[mt] & 1 && face < m_texcoord_custom_build2[mt].Count())
if (m_texcoord_build_type2[mt.ToScalar()] & 1
&& face.ToScalar() < m_texcoord_custom_build2[mt.ToScalar()].Count())
{
BL = m_texcoord_custom_build2[mt][face].m1;
TR = m_texcoord_custom_build2[mt][face].m2;
BL = m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m1;
TR = m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m2;
}
else
{
@@ -310,8 +328,8 @@ public:
{ vec2(0.f, .5f), vec2(.5f, 1.f) },
{ vec2(.5f, .5f), vec2(1.f, 1.f) }
};
BL = data[face][0]; //[tcbt]
TR = data[face][1]; //[tcbt]
BL = data[face.ToScalar()][0]; //[tcbt]
TR = data[face.ToScalar()][1]; //[tcbt]
}
else if (mt == MeshType::Sphere)
mt = mt;
@@ -369,13 +387,16 @@ public:
};

/* A safe enum for VertexDictionnary operations. */
DEF_ENUM(VDictType)
struct VDictType
{
DEF_VALUE
ADD_VALUE_SET(DoesNotExist , -3)
ADD_VALUE_SET(Alone , -2)
ADD_VALUE_SET(Master , -1)
END_E_VALUE
END_ENUM(VDictType)

LOL_DECLARE_ENUM_METHODS(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


+ 11
- 8
src/easymesh/easymeshrender.h 查看文件

@@ -22,14 +22,17 @@ namespace lol
{

//Utility enum for renderers
DEF_ENUM(MeshRender)
DEF_VALUE
ADD_VALUE(NeedData)
ADD_VALUE(NeedConvert)
ADD_VALUE(CanRender)
ADD_VALUE(IgnoreRender)
END_E_VALUE
END_ENUM(MeshRender)
struct MeshRenderDef
{
enum Type
{
NeedData,
NeedConvert,
CanRender,
IgnoreRender,
};
};
typedef SafeEnum<MeshRenderDef> MeshRender;

//Vertex datas for easymesh vertex list.
//TODO : <COORD, NORM, COLOR, UV>


+ 1
- 1
src/gpu/shader.cpp 查看文件

@@ -402,7 +402,7 @@ Shader::Shader(char const *vert, char const *frag)
}
}

if (usage == VertexUsage::MAX || index == -1)
if ((int)usage == VertexUsage::MAX || index == -1)
{
Log::Error("unable to parse attribute semantic from name: %s",
name_buffer);


+ 1
- 0
src/lol/base/all.h 查看文件

@@ -12,6 +12,7 @@
#define __LOL_BASE_ALL_H__

#include <lol/base/types.h>
#include <lol/base/enum.h>
#include <lol/base/log.h>
#include <lol/base/assert.h>
#include <lol/base/array.h>


+ 121
- 0
src/lol/base/enum.h 查看文件

@@ -0,0 +1,121 @@
//
// Lol Engine
//
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
// This program is free software; you can redistribute it and/or
// modify it under the terms of the Do What The Fuck You Want To
// Public License, Version 2, as published by Sam Hocevar. See
// http://www.wtfpl.net/ for more details.
//

#if !defined __LOL_BASE_ENUM_H__
#define __LOL_BASE_ENUM_H__

namespace lol
{

template<typename DEF, typename T = typename DEF::Type>
class SafeEnum : public DEF
{
typedef T Type;
Type m_value;

public:
inline SafeEnum() : m_value() {}
inline SafeEnum(Type v) : m_value(v) {}

/* Allow conversion from/to int */
inline Type ToScalar() const { return m_value; }

/* Safe comparisons between enums of the same type */
friend bool operator == (SafeEnum const &a, SafeEnum const &b)
{
return a.m_value == b.m_value;
}
friend bool operator != (SafeEnum const &a, SafeEnum const &b)
{
return a.m_value != b.m_value;
}
friend bool operator < (SafeEnum const &a, SafeEnum const &b)
{
return a.m_value < b.m_value;
}
friend bool operator > (SafeEnum const &a, SafeEnum const &b)
{
return a.m_value > b.m_value;
}
friend bool operator <= (SafeEnum const &a, SafeEnum const &b)
{
return a.m_value <= b.m_value;
}
friend bool operator >= (SafeEnum const &a, SafeEnum const &b)
{
return a.m_value >= b.m_value;
}
};

//-- 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 */

#endif // __LOL_BASE_ENUM_H__


+ 0
- 155
src/lol/base/types.h 查看文件

@@ -28,161 +28,6 @@ typedef Real<16> real;
/* The “half” type used for 16-bit floating point numbers. */
class half;

//-- STRUCT TEMPLATE:
//DEF_ENUM(NEW_ENUM)
// DEF_VALUE
// ADD_VALUE(NEW_VALUE)
// ADD_VALUE_SET(NEW_VALUE, VALUE_SET)
// END_E_VALUE
// DEF_TEXT
// ADD_TEXT(NEW_VALUE)
// END_TEXT
//END_ENUM(NEW_ENUM)

#define DEF_ENUM(NEW_ENUM) struct NEW_ENUM {
#define END_ENUM(NEW_ENUM) \
inline NEW_ENUM() : m_value(MAX) {} \
inline NEW_ENUM(Value v) : m_value(v) {} \
inline NEW_ENUM(const int8_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const int16_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const int32_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const int64_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const uint8_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const uint16_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const uint32_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const uint64_t & v) : m_value((Value)v) {} \
inline NEW_ENUM(const float & v) : m_value((Value)(int)v) {} \
inline NEW_ENUM(const double & v) : m_value((Value)(int)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; } \
inline float F() { return (float ) m_value; } \
inline double D() { return (double ) m_value; } \
bool operator==(const NEW_ENUM & v) { return m_value == v.m_value; } \
bool operator==(const Value & v) { return m_value == v; } \
bool operator==(const int8_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const int16_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const int32_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const int64_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const uint8_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const uint16_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const uint32_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const uint64_t & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const float & v) { return m_value == NEW_ENUM(v); } \
bool operator==(const double & v) { return m_value == NEW_ENUM(v); } \
bool operator!=(const NEW_ENUM & v) { return m_value != v.m_value; } \
bool operator!=(const Value & v) { return m_value != v; } \
bool operator!=(const int8_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const int16_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const int32_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const int64_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const uint8_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const uint16_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const uint32_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const uint64_t & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const float & v) { return m_value != NEW_ENUM(v); } \
bool operator!=(const double & v) { return m_value != NEW_ENUM(v); } \
bool operator<(const NEW_ENUM & v) { return m_value < v.m_value; } \
bool operator<(const Value & v) { return m_value < v; } \
bool operator<(const int8_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const int16_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const int32_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const int64_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const uint8_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const uint16_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const uint32_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const uint64_t & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const float & v) { return m_value < NEW_ENUM(v); } \
bool operator<(const double & v) { return m_value < NEW_ENUM(v); } \
bool operator>(const NEW_ENUM & v) { return m_value > v.m_value; } \
bool operator>(const Value & v) { return m_value > v; } \
bool operator>(const int8_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const int16_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const int32_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const int64_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const uint8_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const uint16_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const uint32_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const uint64_t & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const float & v) { return m_value > NEW_ENUM(v); } \
bool operator>(const double & v) { return m_value > NEW_ENUM(v); } \
bool operator<=(const NEW_ENUM & v) { return m_value <= v.m_value; } \
bool operator<=(const Value & v) { return m_value <= v; } \
bool operator<=(const int8_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const int16_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const int32_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const int64_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const uint8_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const uint16_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const uint32_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const uint64_t & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const float & v) { return m_value <= NEW_ENUM(v); } \
bool operator<=(const double & v) { return m_value <= NEW_ENUM(v); } \
bool operator>=(const NEW_ENUM & v) { return m_value >= v.m_value; } \
bool operator>=(const Value & v) { return m_value >= v; } \
bool operator>=(const int8_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const int16_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const int32_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const int64_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const uint8_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const uint16_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const uint32_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const uint64_t & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const float & v) { return m_value >= NEW_ENUM(v); } \
bool operator>=(const double & v) { return m_value >= NEW_ENUM(v); } \
};
/*
bool operator== (NEW_ENUM::Value& e1, NEW_ENUM& e2) { return (e2 == e1); }
bool operator== (int& e1, NEW_ENUM& e2) { return (e2 == e1); }
bool operator== (uint32_t& e1, NEW_ENUM& e2) { return (e2 == e1); }
bool operator== (float& e1, NEW_ENUM& e2) { return (e2 == e1); }
bool operator!= (NEW_ENUM::Value& e1, NEW_ENUM& e2) { return (e2 != e1); }
bool operator!= (int& e1, NEW_ENUM& e2) { return (e2 != e1); }
bool operator!= (uint32_t& e1, NEW_ENUM& e2) { return (e2 != e1); }
bool operator!= (float& e1, NEW_ENUM& e2) { return (e2 != e1); }
bool operator< (NEW_ENUM::Value& e1, NEW_ENUM& e2) { return (e2 < e1); }
bool operator< (int& e1, NEW_ENUM& e2) { return (e2 < e1); }
bool operator< (uint32_t& e1, NEW_ENUM& e2) { return (e2 < e1); }
bool operator< (float& e1, NEW_ENUM& e2) { return (e2 < e1); }
bool operator> (NEW_ENUM::Value& e1, NEW_ENUM& e2) { return (e2 > e1); }
bool operator> (int& e1, NEW_ENUM& e2) { return (e2 > e1); }
bool operator> (uint32_t& e1, NEW_ENUM& e2) { return (e2 > e1); }
bool operator> (float& e1, NEW_ENUM& e2) { return (e2 > e1); }
bool operator<= (NEW_ENUM::Value& e1, NEW_ENUM& e2) { return (e2 <= e1); }
bool operator<= (int& e1, NEW_ENUM& e2) { return (e2 <= e1); }
bool operator<= (uint32_t& e1, NEW_ENUM& e2) { return (e2 <= e1); }
bool operator<= (float& e1, NEW_ENUM& e2) { return (e2 <= e1); }
bool operator>= (NEW_ENUM::Value& e1, NEW_ENUM& e2) { return (e2 >= e1); }
bool operator>= (int& e1, NEW_ENUM& e2) { return (e2 >= e1); }
bool operator>= (uint32_t& e1, NEW_ENUM& e2) { return (e2 >= e1); }
bool operator>= (float& e1, NEW_ENUM& e2) { return (e2 >= e1); }
*/

#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 */

#endif // __LOL_BASE_TYPES_H__


+ 7
- 2
src/lol/gpu/shader.h 查看文件

@@ -25,7 +25,8 @@ 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. */
DEF_ENUM(VertexUsage)
struct VertexUsage
{
DEF_VALUE
ADD_VALUE(Position)
ADD_VALUE(BlendWeight)
@@ -43,6 +44,7 @@ DEF_ENUM(VertexUsage)
ADD_VALUE(Depth)
ADD_VALUE(Sample)
END_E_VALUE

DEF_TEXT
ADD_TEXT(Position)
ADD_TEXT(BlendWeight)
@@ -60,6 +62,9 @@ DEF_ENUM(VertexUsage)
ADD_TEXT(Depth)
ADD_TEXT(Sample)
END_TEXT

LOL_DECLARE_ENUM_METHODS(VertexUsage);

private:
static String GetName(Value v, bool use_simple)
{
@@ -92,7 +97,7 @@ public:
}
return tmp + ">";
}
END_ENUM(VertexUsage)
};

struct ShaderUniform
{


+ 10
- 4
src/lol/math/geometry.h 查看文件

@@ -238,7 +238,8 @@ bool TestRayVsTriangle(vec3 const &ray_point, vec3 const &ray_dir,
vec3 const &tri_p0, vec3 const &tri_p1, vec3 const &tri_p2,
vec3 &vi);

DEF_ENUM(RayIntersect)
struct RayIntersect
{
DEF_VALUE
ADD_VALUE(Nothing)
ADD_VALUE(All)
@@ -246,7 +247,9 @@ DEF_ENUM(RayIntersect)
ADD_VALUE(P0)
ADD_VALUE(P1)
END_E_VALUE
END_ENUM(RayIntersect)

LOL_DECLARE_ENUM_METHODS(RayIntersect)
};

#define RAY_ISECT_NOTHING 0
#define RAY_ISECT_ALL 1
@@ -293,13 +296,16 @@ bool TestRayVsPlane(const TV &ray_p0, const TV &ray_p1,
}

/* A safe enum for Primitive edge face. */
DEF_ENUM(PlaneIntersection)
struct PlaneIntersection
{
DEF_VALUE
ADD_VALUE(Back)
ADD_VALUE(Front)
ADD_VALUE(Plane)
END_E_VALUE
END_ENUM(PlaneIntersection)

LOL_DECLARE_ENUM_METHODS(PlaneIntersection)
};

//Point/Plane : Normal must be given normalized.
template <typename TV>


+ 22
- 16
src/lol/sys/file.h 查看文件

@@ -21,22 +21,28 @@
namespace lol
{

DEF_ENUM(FileAccess)
DEF_VALUE
ADD_VALUE(Read)
ADD_VALUE(Write)
END_E_VALUE
END_ENUM(FileAccess)

DEF_ENUM(StreamType)
DEF_VALUE
ADD_VALUE(StdIn)
ADD_VALUE(StdOut)
ADD_VALUE(StdErr)
ADD_VALUE(File)
ADD_VALUE(FileBinary)
END_E_VALUE
END_ENUM(StreamType)
struct FileAccessDef
{
enum Type
{
Read = 0,
Write,
};
};
typedef SafeEnum<FileAccessDef> FileAccess;

struct StreamTypeDef
{
enum Type
{
StdIn,
StdOut,
StdErr,
File,
FileBinary,
};
};
typedef SafeEnum<StreamTypeDef> StreamType;

class File
{


+ 18
- 12
src/lol/sys/thread.h 查看文件

@@ -47,24 +47,30 @@ public:
virtual ~Thread() {}
};

DEF_ENUM(ThreadStatus)
struct ThreadStatus
{
DEF_VALUE
ADD_VALUE(NOTHING)
ADD_VALUE(THREAD_STARTED)
ADD_VALUE(THREAD_STOPPED)
END_E_VALUE
END_ENUM(ThreadStatus)

DEF_ENUM(ThreadJobType)
DEF_VALUE
ADD_VALUE(NONE)
ADD_VALUE(WORK_TODO)
ADD_VALUE(WORK_DONE)
ADD_VALUE(WORK_FAILED)
ADD_VALUE(WORK_FETCHED)
ADD_VALUE(THREAD_STOP)
END_E_VALUE
END_ENUM(ThreadJobType)
LOL_DECLARE_ENUM_METHODS(ThreadStatus)
};

struct ThreadJobTypeDef
{
enum Type
{
NONE,
WORK_TODO,
WORK_DONE,
WORK_FAILED,
WORK_FETCHED,
THREAD_STOP,
};
};
typedef SafeEnum<ThreadJobTypeDef> ThreadJobType;

class ThreadJob
{


+ 2
- 1
src/lolcore.vcxproj 查看文件

@@ -279,6 +279,7 @@
<ClInclude Include="lol\base\all.h" />
<ClInclude Include="lol\base\array.h" />
<ClInclude Include="lol\base\assert.h" />
<ClInclude Include="lol\base\enum.h" />
<ClInclude Include="lol\base\hash.h" />
<ClInclude Include="lol\base\log.h" />
<ClInclude Include="lol\base\map.h" />
@@ -428,4 +429,4 @@
<ImportGroup Label="ExtensionTargets">
<Import Project="$(SolutionDir)\Lol.Fx.targets" />
</ImportGroup>
</Project>
</Project>

+ 4
- 1
src/lolcore.vcxproj.filters 查看文件

@@ -555,6 +555,9 @@
<ClInclude Include="lol\base\assert.h">
<Filter>lol\base</Filter>
</ClInclude>
<ClInclude Include="lol\base\enum.h">
<Filter>lol\base</Filter>
</ClInclude>
<ClInclude Include="lol\base\hash.h">
<Filter>lol\base</Filter>
</ClInclude>
@@ -751,4 +754,4 @@
</None>
<None Include="Makefile.am" />
</ItemGroup>
</Project>
</Project>

+ 6
- 6
src/messageservice.cpp 查看文件

@@ -67,7 +67,7 @@ bool MessageService::Send(MessageBucket id, const String& message)
{
if (g_messageservice)
{
ASSERT(0 <= id && id < g_messageservice->m_bucket.Count());
ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
return g_messageservice->Send(id, message.C());
}
return false;
@@ -77,7 +77,7 @@ bool MessageService::Send(MessageBucket id, const char* message)
{
if (g_messageservice)
{
ASSERT(0 <= id && id < g_messageservice->m_bucket.Count());
ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
MessageService& g = *g_messageservice;
Array<MessageList>& bucket = g.m_bucket[id];
bucket << MessageList(time(nullptr), String(message));
@@ -91,7 +91,7 @@ bool MessageService::FetchFirst(MessageBucket id, String& message)
{
if (g_messageservice)
{
ASSERT(0 <= id && id < g_messageservice->m_bucket.Count());
ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
time_t timestamp;
return g_messageservice->FetchFirst(id, message, timestamp);
}
@@ -102,7 +102,7 @@ bool MessageService::FetchFirst(MessageBucket id, String& message, time_t& times
{
if (g_messageservice)
{
ASSERT(0 <= id && id < g_messageservice->m_bucket.Count());
ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
MessageService& g = *g_messageservice;
Array<MessageList>& bucket = g.m_bucket[id];

@@ -122,7 +122,7 @@ bool MessageService::FetchAll(MessageBucket id, String& message)
{
if (g_messageservice)
{
ASSERT(0 <= id && id < g_messageservice->m_bucket.Count());
ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
time_t timestamp;
return g_messageservice->FetchAll(id, message, timestamp);
}
@@ -133,7 +133,7 @@ bool MessageService::FetchAll(MessageBucket id, String& message, time_t& first_t
{
if (g_messageservice)
{
ASSERT(0 <= id && id < g_messageservice->m_bucket.Count());
ASSERT(0 <= id && (int)id < g_messageservice->m_bucket.Count());
MessageService& g = *g_messageservice;
Array<MessageList>& bucket = g.m_bucket[id];
message = String("");


+ 6
- 3
src/messageservice.h 查看文件

@@ -20,8 +20,9 @@
namespace lol
{

//Utility enum for message service
DEF_ENUM(MessageBucket)
// Utility enum for message service
struct MessageBucket
{
DEF_VALUE
ADD_VALUE(AppIn)
ADD_VALUE(AppOut)
@@ -37,7 +38,9 @@ DEF_ENUM(MessageBucket)
ADD_VALUE(Bckt8)
ADD_VALUE(Bckt9)
END_E_VALUE
END_ENUM(MessageBucket)

LOL_DECLARE_ENUM_METHODS(MessageBucket)
};

//Message list container with time in it
struct MessageList


+ 1
- 1
src/sys/file.cpp 查看文件

@@ -51,7 +51,7 @@ class FileData
m_type == StreamType::FileBinary)
return;
m_type = stream;
switch((int)stream)
switch (stream.ToScalar())
{
#if __CELLOS_LV2__
/* FIXME: no modes, no error checking, no nothing */


Write Preview
Loading…
取消
儲存