Refactored most enums to enum class types.

Author: PearCoding

src/base/CMakeLists.txt

@@ -1,5 +1,6 @@
 set(PR_Src
   PR_Config.h.in
+  Enum.h
   Logger.cpp
   Logger.h
   PrettyPrint.h

src/base/Enum.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "PR_Config.h"
+
+#include <type_traits>
+
+namespace PR {
+template <typename E>
+using enable_enum_t = typename std::enable_if<std::is_enum<E>::value,
+											  typename std::underlying_type<E>::type>::type;
+
+template <typename E>
+constexpr inline enable_enum_t<E> underlying_value(E e) noexcept
+{
+	return static_cast<typename std::underlying_type<E>::type>(e);
+}
+
+template <typename E, typename T>
+constexpr inline typename std::enable_if<std::is_enum<E>::value && std::is_integral<T>::value, E>::type
+to_enum(T value) noexcept
+{
+	return static_cast<E>(value);
+}
+
+template <typename E>
+struct PR_LIB_BASE FlagContainer {
+	using type = typename std::underlying_type<E>::type;
+	type value = 0;
+
+	inline constexpr FlagContainer()		   = default;
+	inline FlagContainer(const FlagContainer&) = default;
+	inline FlagContainer& operator=(const FlagContainer&) = default;
+	inline FlagContainer(FlagContainer&&)				  = default;
+	inline FlagContainer& operator=(FlagContainer&&) = default;
+	inline constexpr FlagContainer(const E& v)
+		: value(underlying_value(v))
+	{
+	}
+	template <typename T>
+	inline constexpr FlagContainer(const T& v, typename std::enable_if<std::is_integral<T>::value>* = 0)
+		: value(v)
+	{
+	}
+	inline operator type() const { return value; }
+	inline FlagContainer& operator|=(const FlagContainer& other)
+	{
+		value |= other.value;
+		return *this;
+	}
+	inline FlagContainer& operator&=(const FlagContainer& other)
+	{
+		value &= other.value;
+		return *this;
+	}
+};
+
+template <typename E>
+inline FlagContainer<E> operator&(const FlagContainer<E>& a, const E& b) { return a.value & PR::underlying_value(b); }
+template <typename E>
+inline FlagContainer<E> operator&(const E& a, const FlagContainer<E>& b) { return PR::underlying_value(a) & b.value; }
+template <typename E>
+inline FlagContainer<E> operator|(const FlagContainer<E>& a, const E& b) { return a.value | PR::underlying_value(b); }
+template <typename E>
+inline FlagContainer<E> operator|(const E& a, const FlagContainer<E>& b) { return PR::underlying_value(a) | b.value; }
+
+} // namespace PR
+
+#define PR_MAKE_FLAGS(single_type, cont_type)                  \
+	using cont_type = typename PR::FlagContainer<single_type>; \
+	inline cont_type operator|(const single_type& a, const single_type& b) { return cont_type(a) | b; }

src/client/TevObserver.cpp

@@ -316,23 +316,23 @@ void TevObserver::updateImageProtocol()
 				PR_OPT_LOOP
 				for (size_t iy = 0; iy < h; ++iy) {
 					for (size_t ix = 0; ix < w; ++ix) {
-						const auto p   = Point2i(sx + ix, sy + iy);
-						const auto fdb = fdb_channel->getFragment(p, 0);
+						const auto p				  = Point2i(sx + ix, sy + iy);
+						const OutputFeedbackFlags fdb = fdb_channel->getFragment(p, 0);
 
 						float r = 0;
-						if (fdb & OF_NaN)
+						if (fdb & OutputFeedback::NaN)
 							r = 1.0f;
-						else if (fdb & OF_Infinite)
+						else if (fdb & OutputFeedback::Infinite)
 							r = 0.5f;
-						else if (fdb & OF_Negative)
+						else if (fdb & OutputFeedback::Negative)
 							r = 0.25f;
 
 						float g = 0;
-						if (fdb & OF_MissingMaterial)
+						if (fdb & OutputFeedback::MissingMaterial)
 							g = 1.0f;
 
 						float b = 0;
-						if (fdb & OF_MissingEmission)
+						if (fdb & OutputFeedback::MissingEmission)
 							b = 1.0f;
 
 						mConnection->Data[UPDATE_TILE_SIZE * UPDATE_TILE_SIZE * (0 + delta) + iy * w + ix] = r;

src/core/entity/IEntity.cpp

@@ -4,7 +4,7 @@
 namespace PR {
 IEntity::IEntity(uint32 emission_id, const std::string& name, const Transformf& transform)
 	: ITransformable(name, transform)
-	, mVisibilityFlags(EVF_All)
+	, mVisibilityFlags((uint8)EntityVisibility::All)
 	, mEmissionID(emission_id)
 {
 }
@@ -20,10 +20,10 @@ std::string IEntity::dumpInformation() const
 		   << "  <IEntity>: " << std::endl
 		   << "    HasEmission:      " << (hasEmission() ? "true" : "false") << std::endl
 		   << "    IsCollidable:     " << (isCollidable() ? "true" : "false") << std::endl
-		   << "    IsCameraVisible:  " << ((visibilityFlags() & EVF_Camera) ? "true" : "false") << std::endl
-		   << "    IsLightVisible:   " << ((visibilityFlags() & EVF_Light) ? "true" : "false") << std::endl
-		   << "    IsBounceVisible:  " << ((visibilityFlags() & EVF_Bounce) ? "true" : "false") << std::endl
-		   << "    IsShadowVisible:  " << ((visibilityFlags() & EVF_Shadow) ? "true" : "false") << std::endl
+		   << "    IsCameraVisible:  " << ((visibilityFlags() & EntityVisibility::Camera) ? "true" : "false") << std::endl
+		   << "    IsLightVisible:   " << ((visibilityFlags() & EntityVisibility::Light) ? "true" : "false") << std::endl
+		   << "    IsBounceVisible:  " << ((visibilityFlags() & EntityVisibility::Bounce) ? "true" : "false") << std::endl
+		   << "    IsShadowVisible:  " << ((visibilityFlags() & EntityVisibility::Shadow) ? "true" : "false") << std::endl
 		   << "    CollisionCost:    " << collisionCost() << std::endl
 		   << "    LocalSurfaceArea: " << localSurfaceArea() << std::endl
 		   << "    BBVolume:         " << worldBoundingBox().volume() << std::endl;

src/core/entity/IEntity.h

@@ -1,16 +1,18 @@
 #pragma once
 
+#include "Enum.h"
 #include "ITransformable.h"
 #include "geometry/BoundingBox.h"
 
 namespace PR {
-enum EntityVisibilityFlag : uint8 {
-	EVF_Camera = 0x1,
-	EVF_Light  = 0x2,
-	EVF_Bounce = 0x4,
-	EVF_Shadow = 0x8,
-	EVF_All	   = EVF_Camera | EVF_Light | EVF_Bounce | EVF_Shadow
+enum class EntityVisibility : uint8 {
+	Camera = (uint8)RayFlag::Camera,
+	Light  = (uint8)RayFlag::Light,
+	Bounce = (uint8)RayFlag::Bounce,
+	Shadow = (uint8)RayFlag::Shadow,
+	All	   = Camera | Light | Bounce | Shadow
 };
+PR_MAKE_FLAGS(EntityVisibility, EntityVisibilityFlags)
 
 struct GeometryPoint;
 struct GeometryRepr;
@@ -54,8 +56,8 @@ class PR_LIB_CORE IEntity : public ITransformable {
 
 	bool isRenderable() const override;
 
-	inline uint8 visibilityFlags() const;
-	inline void setVisibilityFlags(uint8 flags);
+	inline EntityVisibilityFlags visibilityFlags() const;
+	inline void setVisibilityFlags(EntityVisibilityFlags flags);
 
 	// Optional Interface
 	virtual bool isCollidable() const;
@@ -100,7 +102,7 @@ class PR_LIB_CORE IEntity : public ITransformable {
 	inline uint32 emissionID() const { return mEmissionID; }
 
 private:
-	uint8 mVisibilityFlags;
+	EntityVisibilityFlags mVisibilityFlags;
 	const uint32 mEmissionID;
 };
 } // namespace PR

src/core/entity/IEntity.inl

@@ -12,6 +12,6 @@ inline BoundingBox IEntity::worldBoundingBox() const
 	return bb;
 }
 
-inline uint8 IEntity::visibilityFlags() const { return mVisibilityFlags; }
-inline void IEntity::setVisibilityFlags(uint8 flags) { mVisibilityFlags = flags; }
+inline EntityVisibilityFlags IEntity::visibilityFlags() const { return mVisibilityFlags; }
+inline void IEntity::setVisibilityFlags(EntityVisibilityFlags flags) { mVisibilityFlags = flags; }
 } // namespace PR

src/core/entity/ITransformable.cpp

@@ -7,7 +7,6 @@
 namespace PR {
 ITransformable::ITransformable(const std::string& name, const Transformf& transform)
 	: mName(name)
-	, mFlags(0)
 	, mTransform(transform)
 	, mInvTransformCache(mTransform.inverse())
 	, mNormalMatrixCache(mTransform.linear().inverse().transpose())
@@ -34,9 +33,7 @@ std::string ITransformable::dumpInformation() const
 	stream << "<ITransformable> [" << mName << "]: " << std::endl
 		   << "  Position:        " << PR_FMT_MAT(pos) << std::endl
 		   << "  Scale:           " << PR_FMT_MAT(scav) << std::endl
-		   << "  Rotation:        " << PR_FMT_MAT(quat) << std::endl
-		   << "  Flag&Debug:      " << ((mFlags & EF_Debug) != 0 ? "true" : "false") << std::endl
-		   << "  Flag&LocalArea:  " << ((mFlags & EF_LocalArea) != 0 ? "true" : "false") << std::endl;
+		   << "  Rotation:        " << PR_FMT_MAT(quat) << std::endl;
 
 	return stream.str();
 }

src/core/entity/ITransformable.h

@@ -5,11 +5,6 @@
 #include <string>
 
 namespace PR {
-enum EntityFlags {
-	EF_Debug	 = 0x1,
-	EF_LocalArea = 0x2,
-};
-
 #define ENTITY_CLASS \
 	EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
@@ -26,9 +21,6 @@ class PR_LIB_CORE ITransformable {
 	virtual std::string type() const;
 	virtual bool isRenderable() const;
 
-	inline void setFlags(uint8 f);
-	inline uint8 flags() const;
-
 	inline const Transformf& transform() const;
 	inline const Transformf& invTransform() const;
 	inline float volumeScalefactor() const;
@@ -41,7 +33,6 @@ class PR_LIB_CORE ITransformable {
 
 private:
 	const std::string mName;
-	uint8 mFlags;
 
 	const Transformf mTransform;
 	const Transformf mInvTransformCache;

src/core/entity/ITransformable.inl

@@ -15,16 +15,6 @@ inline bool ITransformable::isRenderable() const
 	return false;
 }
 
-inline void ITransformable::setFlags(uint8 f)
-{
-	mFlags = f;
-}
-
-inline uint8 ITransformable::flags() const
-{
-	return mFlags;
-}
-
 inline const Transformf& ITransformable::transform() const
 {
 	return mTransform;

src/core/geometry/BoundingBox.cpp

@@ -74,31 +74,31 @@ BoundingBox::FaceSide BoundingBox::getIntersectionSide(const Vector3f& intersect
 	const Vector3f minDist = (intersection - lowerBound()).cwiseAbs();
 	const Vector3f maxDist = (intersection - upperBound()).cwiseAbs();
 
-	BoundingBox::FaceSide side = FS_Left;
-	float f					   = minDist(0);
+	FaceSide side = FaceSide::Left;
+	float f		  = minDist(0);
 
 	if (maxDist(0) < f) {
-		side = FS_Right;
+		side = FaceSide::Right;
 		f	 = maxDist(0);
 	}
 
 	if (minDist(1) < f) {
-		side = FS_Bottom;
+		side = FaceSide::Bottom;
 		f	 = minDist(1);
 	}
 
 	if (maxDist(1) < f) {
-		side = FS_Top;
+		side = FaceSide::Top;
 		f	 = maxDist(1);
 	}
 
 	if (minDist(2) < f) {
-		side = FS_Front;
+		side = FaceSide::Front;
 		f	 = minDist(2);
 	}
 
 	if (maxDist(2) < f) {
-		side = FS_Back;
+		side = FaceSide::Back;
 	}
 
 	return side;
@@ -110,27 +110,27 @@ Plane BoundingBox::getFace(FaceSide side) const
 
 	switch (side) {
 	default:
-	case FS_Front:
+	case FaceSide::Front:
 		return Plane(lowerBound(),
 					 Vector3f(diff(0), 0, 0),
 					 Vector3f(0, diff(1), 0));
-	case FS_Back:
+	case FaceSide::Back:
 		return Plane(Vector3f(upperBound()(0), lowerBound()(1), upperBound()(2)),
 					 Vector3f(-diff(0), 0, 0),
 					 Vector3f(0, diff(1), 0));
-	case FS_Left:
+	case FaceSide::Left:
 		return Plane(Vector3f(lowerBound()(0), lowerBound()(1), upperBound()(2)),
 					 Vector3f(0, 0, -diff(2)),
 					 Vector3f(0, diff(1), 0));
-	case FS_Right:
+	case FaceSide::Right:
 		return Plane(Vector3f(upperBound()(0), lowerBound()(1), lowerBound()(2)),
 					 Vector3f(0, 0, diff(2)),
 					 Vector3f(0, diff(1), 0));
-	case FS_Top:
+	case FaceSide::Top:
 		return Plane(Vector3f(lowerBound()(0), upperBound()(1), lowerBound()(2)),
 					 Vector3f(diff(0), 0, 0),
 					 Vector3f(0, 0, diff(2)));
-	case FS_Bottom:
+	case FaceSide::Bottom:
 		return Plane(Vector3f(upperBound()(0), lowerBound()(1), lowerBound()(2)),
 					 Vector3f(-diff(0), 0, 0),
 					 Vector3f(0, 0, diff(2)));