Refactoring

include/anki/gl/GlCommon.h

@@ -14,9 +14,6 @@
 #include "anki/util/StdTypes.h"
 #include "anki/Math.h"
 
-#include <atomic>
-#include <string>
-
 #if ANKI_GL == ANKI_GL_DESKTOP
 #	if ANKI_OS == ANKI_OS_WINDOWS && !defined(GLEW_STATIC)
 #		define GLEW_STATIC

include/anki/gl/GlHandle.h

@@ -7,6 +7,7 @@
 #define ANKI_GL_GL_HANDLE_H
 
 #include "anki/gl/GlCommon.h"
+#include "anki/util/Atomic.h"
 
 namespace anki {
 
@@ -243,7 +244,7 @@ private:
 	{
 	public:
 		Y* m_ptr;
-		std::atomic<I32> m_refcount;
+		Atomic<I32> m_refcount;
 
 		virtual ~CtrlBlockBase()
 		{}
@@ -311,7 +312,7 @@ private:
 		/// @note Its mutable because we want read/write access to it
 		mutable GlDevice* m_manager; 
 
-		std::atomic<GlHandleState> m_state;
+		Atomic<GlHandleState> m_state;
 		
 		void deletePtr()
 		{

include/anki/renderer/Dbg.h

@@ -10,6 +10,7 @@
 #include "anki/Gl.h"
 #include "anki/renderer/DebugDrawer.h"
 #include "anki/util/Bitset.h"
+#include "anki/util/Enum.h"
 
 namespace anki {
 
@@ -32,6 +33,7 @@ public:
 		PHYSICS = 1 << 4,
 		ALL = SPATIAL | FRUSTUMABLE | SECTOR | OCTREE | PHYSICS
 	};
+	ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(Flag, friend);
 
 	Bool getDepthTestEnabled() const
 	{
@@ -50,9 +52,9 @@ public:
 
 private:
 	GlFramebufferHandle m_fb;
-	std::unique_ptr<DebugDrawer> m_drawer;
+	DebugDrawer* m_drawer = nullptr;
 	// Have it as ptr because the constructor calls opengl
-	std::unique_ptr<SceneDebugDrawer> m_sceneDrawer;
+	SceneDebugDrawer* m_sceneDrawer = nullptr;
 	Bool8 m_depthTest = true;
 
 	Dbg(Renderer* r)

include/anki/renderer/DebugDrawer.h

@@ -16,6 +16,9 @@
 
 namespace anki {
 
+// Forward
+class Renderer;
+
 /// @addtogroup renderer
 /// @{
 
@@ -23,7 +26,7 @@ namespace anki {
 class DebugDrawer
 {
 public:
-	DebugDrawer();
+	DebugDrawer(Renderer* r);
 	~DebugDrawer();
 
 	void drawGrid();
@@ -104,7 +107,7 @@ class CollisionDebugDrawer: public CollisionShape::ConstVisitor
 public:
 	/// Constructor
 	CollisionDebugDrawer(DebugDrawer* dbg)
-		: m_dbg(dbg)
+	:	m_dbg(dbg)
 	{}
 
 	void visit(const LineSegment&);
@@ -134,7 +137,7 @@ class SceneDebugDrawer
 {
 public:
 	SceneDebugDrawer(DebugDrawer* d)
-		: m_dbg(d)
+	:	m_dbg(d)
 	{}
 
 	~SceneDebugDrawer()

include/anki/renderer/Ms.h

@@ -70,7 +70,8 @@ private:
 	Array<Plane, 2> m_planes;
 
 	Ms(Renderer* r)
-		: RenderingPass(r), m_ez(r)
+	:	RenderingPass(r), 
+		m_ez(r)
 	{}
 
 	~Ms();

include/anki/renderer/Renderer.h

@@ -224,11 +224,13 @@ public:
 	GlProgramPipelineHandle createDrawQuadProgramPipeline(
 		GlProgramHandle frag);
 
-	GlDevice& getGlDevice();
-
 	/// @privatesection
 	/// @{
+	GlDevice& _getGlDevice();
+
 	HeapAllocator<U8>& _getAllocator();
+
+	ResourceManager& _getResourceManager();
 	/// @}
 
 private:

include/anki/renderer/RenderingPass.h

@@ -15,6 +15,7 @@ namespace anki {
 
 // Forward
 class Renderer;
+class ResourceManager;
 
 /// @addtogroup renderer
 /// @{
@@ -46,14 +47,20 @@ protected:
 	HeapAllocator<U8>& getAllocator();
 
 	GlDevice& getGlDevice();
+
+	ResourceManager& getResourceManager();
 };
 
 /// Blurring pass
-class BlurringRenderingPass
+class BlurringRenderingPass: public RenderingPass
 {
 protected:
 	U32 m_blurringIterationsCount = 1; ///< The blurring iterations
 
+	BlurringRenderingPass(Renderer* r)
+	:	RenderingPass(r)
+	{}
+
 	class Direction
 	{
 	public:

include/anki/renderer/Sslr.h

@@ -16,7 +16,7 @@ namespace anki {
 /// @{
 
 /// Screen space local reflections pass
-class Sslr: public RenderingPass, public BlurringRenderingPass
+class Sslr: public BlurringRenderingPass
 {
 	friend class Pps;
 
@@ -40,7 +40,7 @@ private:
 	GlProgramPipelineHandle m_blitPpline;
 
 	Sslr(Renderer* r)
-	:	RenderingPass(r)
+	:	BlurringRenderingPass(r)
 	{}
 
 	void init(const ConfigSet& initializer);

include/anki/scene/SceneGraph.h

@@ -212,7 +212,7 @@ private:
 
 	EventManager m_events;
 
-	std::atomic<U32> m_objectsMarkedForDeletionCount;
+	AtomicU32 m_objectsMarkedForDeletionCount;
 
 	/// Put a node in the appropriate containers
 	void registerNode(SceneNode* node);

include/anki/util/Atomic.h

@@ -22,6 +22,9 @@ using AtomicU32 = std::atomic<U32>;
 using AtomicI64 = std::atomic<I64>;
 using AtomicU64 = std::atomic<U64>;
 
+template<typename T>
+using Atomic = std::atomic<T>;
+
 /// @}
 
 } // end namespace anki

include/anki/util/Enum.h

@@ -6,22 +6,101 @@
 #ifndef ANKI_UTIL_ENUM_H
 #define ANKI_UTIL_ENUM_H
 
-#include "anki/util/StdTypes.h"
+#include "anki/Config.h"
 
-#define ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(enum_, qualifier_) \
-	qualifier_ enum_ operator|(enum_ a, enum_ b) \
+/// @privatesection
+/// @{
+
+// Re-implement std::underlying_type to avoid including the whole typetraits
+// header
+template<typename TEnum>
+struct EnumUnderlyingType
+{
+	using Type = __underlying_type(TEnum);
+};
+
+#define _ANKI_ENUM_OPERATOR(enum_, qualifier_, operator_, selfOperator_) \
+	qualifier_ enum_ operator operator_ (enum_ a, enum_ b) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>( \
+			static_cast<Int>(a) operator_ static_cast<Int>(b)); \
+	} \
+	qualifier_ enum_ operator operator_ ( \
+		enum_ a, EnumUnderlyingType<enum_>::Type b) \
 	{ \
-		return static_cast<enum_>(static_cast<U64>(a) | static_cast<U64>(b)); \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>(static_cast<Int>(a) operator_ b); \
 	} \
-	qualifier_ void operator|=(enum_& a, enum_ b) \
+	qualifier_ enum_ operator operator_ ( \
+		EnumUnderlyingType<enum_>::Type a, enum_ b) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>(a operator_ static_cast<Int>(b)); \
+	} \
+	qualifier_ enum_& operator selfOperator_ (enum_& a, enum_ b) \
+	{ \
+		a = a operator_ b; \
+		return a; \
+	} \
+
+#define _ANKI_ENUM_UNARAY_OPERATOR(enum_, qualifier_, operator_) \
+	qualifier_ enum_ operator operator_ (enum_ a) \
 	{ \
-		a = static_cast<enum_>(static_cast<U64>(a) | static_cast<U64>(b)); \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		return static_cast<enum_>(operator_ static_cast<Int>(a)); \
+	}
+
+#define _ANKI_ENUM_INCREMENT_DECREMENT(enum_, qualifier_) \
+	qualifier_ enum_& operator++(enum_& a) \
+	{ \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		a = static_cast<enum_>(static_cast<Int>(a) + 1); \
+		return  a; \
 	} \
-	qualifier_ enum_ operator&(enum_ a, enum_ b) \
+	qualifier_ enum_& operator--(enum_& a) \
 	{ \
-		return static_cast<enum_>(static_cast<U64>(a) & static_cast<U64>(b)); \
+		using Int = EnumUnderlyingType<enum_>::Type; \
+		a = static_cast<enum_>(static_cast<Int>(a) - 1); \
+		return  a; \
 	}
 
+/// @}
+
+/// @addtogroup util_other
+/// @{
+
+/// Implement all those functions that will make a stronly typed enum behave 
+/// like the old type of enums.
+#define ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(enum_, qualifier_) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, |, |=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, &, &=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, ^, ^=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, +, +=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, -, -=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, *, *=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, /, /=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, <<, <<=) \
+	_ANKI_ENUM_OPERATOR(enum_, qualifier_, >>, >>=) \
+	_ANKI_ENUM_UNARAY_OPERATOR(enum_, qualifier_, ~) \
+	_ANKI_ENUM_INCREMENT_DECREMENT(enum_, qualifier_)
+
+/// Convert enum to the underlying type.
+template<typename TEnum>
+inline typename EnumUnderlyingType<TEnum>::Type enumToValue(TEnum e)
+{
+	return static_cast<typename EnumUnderlyingType<TEnum>::Type>(e);
+}
+
+/// Convert enum to the underlying type.
+template<typename TEnum>
+inline TEnum valueToEnum(typename EnumUnderlyingType<TEnum>::Type v)
+{
+	return static_cast<TEnum>(v);
+}
+
+/// @}
+
 #endif
 
 

src/renderer/Dbg.cpp

@@ -10,18 +10,29 @@
 #include "anki/scene/Camera.h"
 #include "anki/scene/Light.h"
 #include "anki/core/Logger.h"
+#include "anki/util/Enum.h"
 
 namespace anki {
 
 //==============================================================================
 Dbg::~Dbg()
-{}
+{
+	if(m_drawer != nullptr)
+	{
+		getAllocator().deleteInstance(m_drawer);
+	}
+
+	if(m_sceneDrawer != nullptr)
+	{
+		getAllocator().deleteInstance(m_sceneDrawer);
+	}
+}
 
 //==============================================================================
 void Dbg::init(const ConfigSet& initializer)
 {
 	m_enabled = initializer.get("dbg.enabled");
-	enableBits(DF_ALL);
+	enableBits(enumToValue(Flag::ALL));
 
 	try
 	{
@@ -42,8 +53,8 @@ void Dbg::init(const ConfigSet& initializer)
 				{m_r->getMs()._getDepthRt(), GL_DEPTH_ATTACHMENT}});
 		}
 
-		m_drawer.reset(new DebugDrawer);
-		m_sceneDrawer.reset(new SceneDebugDrawer(m_drawer.get()));
+		m_drawer = getAllocator().newInstance<DebugDrawer>();
+		m_sceneDrawer = getAllocator().newInstance<SceneDebugDrawer>(m_drawer);
 
 		jobs.finish();
 	}
@@ -78,30 +89,12 @@ void Dbg::run(GlCommandBufferHandle& jobs)
 			return;
 		}
 
-		if(bitsEnabled(DF_SPATIAL) && sp)
+		if(bitsEnabled(enumToValue(Flag::SPATIAL)) && sp)
 		{
 			m_sceneDrawer->draw(node);
 		}
 	});
 
-	// Draw sectors
-	for(const Sector* sector : scene.getSectorGroup().getSectors())
-	{
-		//if(sector->isVisible())
-		{
-			if(bitsEnabled(DF_SECTOR))
-			{
-				m_sceneDrawer->draw(*sector);
-			}
-		}
-	}
-
-	// Physics
-	if(bitsEnabled(DF_PHYSICS))
-	{
-		//scene.getPhysics().debugDraw();
-	}
-
 	// XXX
 #if 0
 	if(0)
@@ -194,7 +187,7 @@ void Dbg::run(GlCommandBufferHandle& jobs)
 		Aabb s0(pos0 - Vec4(1.0, 1.0, 2.0, 0.0), pos0 + Vec4(1.0, 1.0, 2.0, 0.0));
 		Obb s1(pos1, rot1, Vec4(1.0, 0.5, 2.5, 0.0));
 
-		CollisionDebugDrawer dr(m_drawer.get());
+		CollisionDebugDrawer dr(m_drawer);
 
 		GjkEpa gjk(100, 100, 100);
 		ContactPoint cp;

src/renderer/DebugDrawer.cpp

@@ -4,6 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include "anki/renderer/DebugDrawer.h"
+#include "anki/renderer/Renderer.h"
 #include "anki/resource/ProgramResource.h"
 #include "anki/Collision.h"
 #include "anki/Scene.h"
@@ -18,12 +19,12 @@ namespace anki {
 //==============================================================================
 
 //==============================================================================
-DebugDrawer::DebugDrawer()
+DebugDrawer::DebugDrawer(Renderer* r)
 {
-	GlDevice& gl = GlDeviceSingleton::get();
+	GlDevice& gl = r->_getGlDevice();
 
-	m_vert.load("shaders/Dbg.vert.glsl");
-	m_frag.load("shaders/Dbg.frag.glsl");
+	m_vert.load("shaders/Dbg.vert.glsl", &r->_getResourceManager());
+	m_frag.load("shaders/Dbg.frag.glsl", &r->_getResourceManager());
 
 	GlCommandBufferHandle jobs(&gl);
 
@@ -137,7 +138,7 @@ void DebugDrawer::flushInternal(GLenum primitive)
 	m_vertBuff.bindVertexBuffer(m_jobs, 
 		4, GL_FLOAT, true, sizeof(Vertex), sizeof(Vec4), 1); // Color
 
-	m_jobs.draw(primitive, clientVerts);
+	m_jobs.drawArrays(primitive, clientVerts);
 }
 
 //==============================================================================

src/renderer/Hdr.cpp

@@ -5,7 +5,6 @@
 
 #include "anki/renderer/Hdr.h"
 #include "anki/renderer/Renderer.h"
-#include <sstream>
 
 namespace anki {
 
@@ -16,7 +15,7 @@ Hdr::~Hdr()
 //==============================================================================
 void Hdr::initFb(GlFramebufferHandle& fb, GlTextureHandle& rt)
 {
-	GlDevice& gl = GlDeviceSingleton::get();
+	GlDevice& gl = getGlDevice();
 
 	m_r->createRenderTarget(m_width, m_height, GL_RGB8, GL_RGB, 
 		GL_UNSIGNED_BYTE, 1, rt);
@@ -56,7 +55,7 @@ void Hdr::initInternal(const ConfigSet& initializer)
 	initFb(m_vblurFb, m_vblurRt);
 
 	// init shaders
-	GlDevice& gl = GlDeviceSingleton::get();
+	GlDevice& gl = getGlDevice();
 	GlCommandBufferHandle jobs(&gl);
 
 	m_commonBuff = GlBufferHandle(jobs, GL_SHADER_STORAGE_BUFFER, 
@@ -66,7 +65,7 @@ void Hdr::initInternal(const ConfigSet& initializer)
 
 	jobs.flush();
 
-	m_toneFrag.load("shaders/PpsHdr.frag.glsl");
+	m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager());
 
 	m_tonePpline = 
 		m_r->createDrawQuadProgramPipeline(m_toneFrag->getGlProgram());
@@ -74,28 +73,35 @@ void Hdr::initInternal(const ConfigSet& initializer)
 	const char* SHADER_FILENAME = 
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
-	std::stringstream pps;
-	pps << "#define HPASS\n"
+	String pps(getAllocator());
+	pps.sprintf("#define HPASS\n"
 		"#define COL_RGB\n"
-		"#define BLURRING_DIST float(" << m_blurringDist << ")\n"
-		"#define IMG_DIMENSION " << m_height << "\n"
-		"#define SAMPLES " << (U)initializer.get("pps.hdr.samples") << "\n";
+		"#define BLURRING_DIST float(%f)\n"
+		"#define IMG_DIMENSION %u\n"
+		"#define SAMPLES %u\n",
+		m_blurringDist, m_height, 
+		static_cast<U>(initializer.get("pps.hdr.samples")));
 
-	m_hblurFrag.load(ProgramResource::createSrcCodeToCache(
-		SHADER_FILENAME, pps.str().c_str(), "r_").c_str());
+	m_hblurFrag.load(ProgramResource::createSourceToCache(
+		SHADER_FILENAME, pps.toCString(), "r_", 
+		getResourceManager()).toCString(),
+		&getResourceManager());
 
 	m_hblurPpline = 
 		m_r->createDrawQuadProgramPipeline(m_hblurFrag->getGlProgram());
 
-	pps.str("");
-	pps << "#define VPASS\n"
+	pps.sprintf("#define VPASS\n"
 		"#define COL_RGB\n"
-		"#define BLURRING_DIST float(" << m_blurringDist << ")\n"
-		"#define IMG_DIMENSION " << m_width << "\n"
-		"#define SAMPLES " << (U)initializer.get("pps.hdr.samples") << "\n";
-
-	m_vblurFrag.load(ProgramResource::createSrcCodeToCache(
-		SHADER_FILENAME, pps.str().c_str(), "r_").c_str());
+		"#define BLURRING_DIST float(%f)\n"
+		"#define IMG_DIMENSION %u\n"
+		"#define SAMPLES %u\n",
+		m_blurringDist, m_width, 
+		static_cast<U>(initializer.get("pps.hdr.samples")));
+
+	m_vblurFrag.load(ProgramResource::createSourceToCache(
+		SHADER_FILENAME, pps.toCString(), "r_",
+		getResourceManager()).toCString(),
+		&getResourceManager());
 
 	m_vblurPpline = 
 		m_r->createDrawQuadProgramPipeline(m_vblurFrag->getGlProgram());

src/renderer/Ms.cpp

@@ -32,7 +32,7 @@ void Ms::createRt(U32 index, U32 samples)
 	m_r->createRenderTarget(m_r->getWidth(), m_r->getHeight(), GL_RGBA8,
 		GL_RGBA, GL_UNSIGNED_BYTE, samples, plane.m_rt1);
 
-	GlDevice& gl = GlDeviceSingleton::get();
+	GlDevice& gl = getGlDevice();
 	GlCommandBufferHandle jobs(&gl);
 
 	plane.m_fb = GlFramebufferHandle(
@@ -63,7 +63,7 @@ void Ms::init(const ConfigSet& initializer)
 				GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT,
 				GL_UNSIGNED_INT, 1, m_smallDepthRt);
 
-			GlDevice& gl = GlDeviceSingleton::get();
+			GlDevice& gl = getGlDevice();
 			GlCommandBufferHandle jobs(&gl);
 
 			m_smallDepthRt.setFilter(jobs, GlTextureHandle::Filter::LINEAR);

src/renderer/RenderingPass.cpp

@@ -5,7 +5,7 @@
 
 #include "anki/renderer/RenderingPass.h"
 #include "anki/renderer/Renderer.h"
-#include <sstream>
+#include "anki/util/Enum.h"
 
 namespace anki {
 
@@ -15,26 +15,40 @@ GlDevice& RenderingPass::getGlDevice()
 	return m_r->getGlDevice();
 }
 
+//==============================================================================
+HeapAllocator<U8>& RenderingPass::getAllocator()
+{
+	return m_r->_getAllocator();
+}
+
+//==============================================================================
+ResourceManager& RenderingPass::getResourceManager()
+{
+	return m_r->_getResourceManager();
+}
+
 //==============================================================================
 void BlurringRenderingPass::initBlurring(
 	Renderer& r, U width, U height, U samples, F32 blurringDistance)
 {
-	GlDevice& gl = GlDeviceSingleton::get();
+	GlDevice& gl = getGlDevice();
 	GlCommandBufferHandle jobs(&gl);
 
-	Array<std::stringstream, 2> pps;
+	Array<String, 2> pps = {{String(getAllocator()), String(getAllocator())}};
 
-	pps[1] << "#define HPASS\n"
+	pps[1].sprintf("#define HPASS\n"
 		"#define COL_RGB\n"
-		"#define BLURRING_DIST float(" << blurringDistance << ")\n"
-		"#define IMG_DIMENSION " << height << "\n"
-		"#define SAMPLES " << samples << "\n";
+		"#define BLURRING_DIST float(%f)\n"
+		"#define IMG_DIMENSION %u\n"
+		"#define SAMPLES %u\n", 
+		blurringDistance, height, samples);
 
-	pps[0] << "#define VPASS\n"
+	pps[0].sprintf("#define VPASS\n"
 		"#define COL_RGB\n"
-		"#define BLURRING_DIST float(" << blurringDistance << ")\n"
-		"#define IMG_DIMENSION " << width << "\n"
-		"#define SAMPLES " << samples << "\n";
+		"#define BLURRING_DIST float(%f)\n"
+		"#define IMG_DIMENSION %u\n"
+		"#define SAMPLES %u\n",
+		blurringDistance, width, samples);
 
 	for(U i = 0; i < 2; i++)
 	{
@@ -51,9 +65,10 @@ void BlurringRenderingPass::initBlurring(
 		dir.m_fb = GlFramebufferHandle(
 			jobs, {{dir.m_rt, GL_COLOR_ATTACHMENT0}});
 
-		dir.m_frag.load(ProgramResource::createSrcCodeToCache(
+		dir.m_frag.load(ProgramResource::createSourceToCache(
 			"shaders/VariableSamplingBlurGeneric.frag.glsl", 
-			pps[i].str().c_str(), "r_").c_str());
+			pps[i].toCString(), "r_", getResourceManager()).toCString(),
+			&getResourceManager());
 
 		dir.m_ppline = 
 			r.createDrawQuadProgramPipeline(dir.m_frag->getGlProgram());
@@ -65,19 +80,22 @@ void BlurringRenderingPass::initBlurring(
 //==============================================================================
 void BlurringRenderingPass::runBlurring(Renderer& r, GlCommandBufferHandle& jobs)
 {
-	m_dirs[(U)DirectionEnum::VERTICAL].m_rt.bind(jobs, 1); // H pass input
-	m_dirs[(U)DirectionEnum::HORIZONTAL].m_rt.bind(jobs, 0); // V pass input
+	// H pass input
+	m_dirs[enumToValue(DirectionEnum::VERTICAL)].m_rt.bind(jobs, 1); 
+
+	// V pass input
+	m_dirs[enumToValue(DirectionEnum::HORIZONTAL)].m_rt.bind(jobs, 0); 
 
 	for(U32 i = 0; i < m_blurringIterationsCount; i++)
 	{
 		// hpass
-		m_dirs[(U)DirectionEnum::HORIZONTAL].m_fb.bind(jobs, true);
-		m_dirs[(U)DirectionEnum::HORIZONTAL].m_ppline.bind(jobs);
+		m_dirs[enumToValue(DirectionEnum::HORIZONTAL)].m_fb.bind(jobs, true);
+		m_dirs[enumToValue(DirectionEnum::HORIZONTAL)].m_ppline.bind(jobs);
 		r.drawQuad(jobs);
 
 		// vpass
-		m_dirs[(U)DirectionEnum::VERTICAL].m_fb.bind(jobs, true);
-		m_dirs[(U)DirectionEnum::VERTICAL].m_ppline.bind(jobs);
+		m_dirs[enumToValue(DirectionEnum::VERTICAL)].m_fb.bind(jobs, true);
+		m_dirs[enumToValue(DirectionEnum::VERTICAL)].m_ppline.bind(jobs);
 		r.drawQuad(jobs);
 	}
 }