RenderGraph: Design

src/anki/gr/GrObjectCache.h

@@ -47,18 +47,8 @@ private:
 		}
 	};
 
-	/// Hash compare.
-	class Compare
-	{
-	public:
-		Bool operator()(const Key& a, const Key& b) const
-		{
-			return a == b;
-		}
-	};
-
 	GrManager* m_gr;
-	HashMap<U64, GrObject*, Hasher, Compare> m_map;
+	HashMap<U64, GrObject*, Hasher> m_map;
 	Mutex m_mtx;
 
 	/// Try to find an object in the cache.

src/anki/gr/RenderGraph.cpp

@@ -0,0 +1,79 @@
+// Copyright (C) 2009-2017, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#include <anki/gr/RenderGraph.h>
+#include <anki/gr/GrManager.h>
+#include <anki/gr/Texture.h>
+
+namespace anki
+{
+
+RenderGraph::RenderGraph(GrManager* gr)
+	: m_gr(gr)
+{
+	ANKI_ASSERT(gr);
+}
+
+RenderGraphHandle RenderGraph::importRenderTarget(CString name, TexturePtr tex)
+{
+	const PtrSize crntSize = m_renderTargets.getSize();
+	m_renderTargets.resize(m_gr->getAllocator(), crntSize + 1);
+
+	RenderTarget& target = m_renderTargets.getBack();
+	target.m_imported = true;
+	target.m_tex = tex;
+
+	if(name.getLength())
+	{
+		ANKI_ASSERT(name.getLength() <= MAX_GR_OBJECT_NAME_LENGTH);
+		strcpy(&target.m_name[0], &name[0]);
+	}
+	else
+	{
+		static const char* NA = "N/A";
+		strcpy(&target.m_name[0], NA);
+	}
+
+	return crntSize;
+}
+
+void RenderGraph::bake()
+{
+	// Walk the graph and create pass batches
+	/*
+	DynamicArray<PassBatch> batches;
+	List<Pass> remainingPasses = m_passes;
+	while(!remainingPasses.isEmpty())
+	{
+		PassBatch newBatch;
+
+		for(pass : remainingPasses)
+		{
+			if(pass.noDependencies() || pass.fullfiledDependencies())
+			{
+				newBatch.pushBack(pass);
+				remainingPasses.erase(pass);
+			}
+		}
+	}
+	*/
+
+	// Find out what barriers we need between passes
+	/*
+	for(batch : batches)
+	{
+		consumers = gatherConsumers(batch);
+
+		for(c : consumers)
+		{
+			lastProducer = findLastProducer(c);
+		}
+
+
+	}
+	*/
+}
+
+} // end namespace anki

src/anki/gr/RenderGraph.h

@@ -7,11 +7,12 @@
 
 #include <anki/gr/Common.h>
 #include <anki/gr/Enums.h>
+#include <anki/util/HashMap.h>
 
 namespace anki
 {
 
-/// @addtogroup gr
+/// @addtogroup graphics
 /// @{
 
 /// XXX
@@ -53,6 +54,12 @@ public:
 class RenderGraph : public NonCopyable
 {
 public:
+	RenderGraph(GrManager* gr);
+
+	~RenderGraph();
+
+	/// @name 1st step methods
+	/// @{
 	RenderGraphHandle importRenderTarget(CString name, TexturePtr tex);
 
 	RenderGraphHandle newRenderTarget(CString name, const TextureInitInfo& texInf);
@@ -66,24 +73,81 @@ public:
 		RenderTargetInfo depthStencilAttachment,
 		WeakArray<RenderGraphDependency> consumers,
 		WeakArray<RenderGraphDependency> producers,
-		void* userData,
 		RenderGraphWorkCallback callback,
+		void* userData,
 		U32 secondLevelCmdbsCount);
 
 	/// For compute or other work (mipmap gen).
 	void registerNonRenderPass(CString name,
 		WeakArray<RenderGraphDependency> consumers,
 		WeakArray<RenderGraphDependency> producers,
-		void* userData,
-		RenderGraphWorkCallback callback);
+		RenderGraphWorkCallback callback,
+		void* userData);
+	/// @}
 
-	TexturePtr getTexture(RenderGraphHandle handle);
+	/// @name 2nd step methods
+	/// @{
+	void bake();
+	/// @}
 
-	BufferPtr getBuffer(RenderGraphHandle handle);
+	/// @name 3rd step methods
+	/// @{
+
+	/// Will call a number of RenderGraphWorkCallback that populate 2nd level command buffers.
+	void runSecondLevel();
+	/// @}
+
+	/// @name 4th step methods
+	/// @{
 
+	/// Will call a number of RenderGraphWorkCallback that populate 1st level command buffers.
 	void run();
+	/// @}
+
+	/// @name 3rd and 4th step methods
+	/// @{
+	TexturePtr getTexture(RenderGraphHandle handle);
+	BufferPtr getBuffer(RenderGraphHandle handle);
+	/// @}
 
+	/// @name 5th step methods
+	/// @{
+
+	/// Reset the graph for a new frame. All previously created RenderGraphHandle are invalid after that call.
 	void reset();
+	/// @}
+
+private:
+	GrManager* m_gr;
+
+	class Cache
+	{
+	public:
+		HashMap<TextureInitInfo, TexturePtr> m_renderTargets; ///< Non-imported render targets.
+		HashMap<FramebufferInitInfo, FramebufferPtr> m_framebuffers;
+	} m_cache;
+
+	class RenderTarget
+	{
+	public:
+		TexturePtr m_tex;
+		Bool8 m_imported = false;
+		Array<char, MAX_GR_OBJECT_NAME_LENGTH + 1> m_name;
+	};
+
+	DynamicArray<RenderTarget> m_renderTargets;
+	RenderGraphHandle m_lastRtHandle = 0;
+
+	class Pass
+	{
+	public:
+		Pass* m_next = nullptr;
+		FramebufferPtr m_framebuffer;
+		Array<char, MAX_GR_OBJECT_NAME_LENGTH + 1> m_name;
+	};
+
+	DynamicArray<Pass> m_passes;
+	RenderGraphHandle m_lastPassHandle = 0;
 };
 /// @}
 

src/anki/gr/Texture.h

@@ -45,6 +45,11 @@ public:
 class TextureInitInfo : public GrBaseInitInfo
 {
 public:
+	U32 m_width = 0;
+	U32 m_height = 0;
+	U32 m_depth = 1; //< Relevant only for 3D textures.
+	U32 m_layerCount = 1; ///< Relevant only for texture arrays.
+
 	TextureType m_type = TextureType::_2D;
 
 	TextureUsageBit m_usage = TextureUsageBit::NONE; ///< How the texture will be used.
@@ -53,10 +58,6 @@ public:
 	/// It's usual usage. That way you won't need to call CommandBuffer::informTextureXXXCurrentUsage() all the time.
 	TextureUsageBit m_usageWhenEncountered = TextureUsageBit::NONE;
 
-	U32 m_width = 0;
-	U32 m_height = 0;
-	U32 m_depth = 1; //< Relevant only for 3D textures.
-	U32 m_layerCount = 1; ///< Relevant only for texture arrays.
 	U8 m_mipmapsCount = 1;
 
 	PixelFormat m_format;
@@ -71,6 +72,18 @@ public:
 		, m_sampling(name)
 	{
 	}
+
+	U64 computeHash() const
+	{
+		const U8* start = reinterpret_cast<const U8*>(&m_width);
+		const U8* end = reinterpret_cast<const U8*>(&m_samples) + sizeof(m_samples);
+		ANKI_ASSERT((end - start == 24) && "Class needs to be tightly packed since we hash it");
+
+		const U8* starts = reinterpret_cast<const U8*>(&m_sampling.m_minLod);
+		const U8* ends = reinterpret_cast<const U8*>(&m_sampling.m_repeat) + sizeof(m_sampling.m_repeat);
+
+		return appendHash(starts, ends - starts, anki::computeHash(start, end - start));
+	}
 };
 
 /// GPU texture

src/anki/gr/vulkan/TextureImpl.h

@@ -139,16 +139,7 @@ private:
 		}
 	};
 
-	class ViewCompare
-	{
-	public:
-		Bool operator()(const VkImageViewCreateInfo& a, const VkImageViewCreateInfo& b) const
-		{
-			return memcmp(&a, &b, sizeof(a)) == 0;
-		}
-	};
-
-	HashMap<VkImageViewCreateInfo, VkImageView, ViewHasher, ViewCompare> m_viewsMap;
+	HashMap<VkImageViewCreateInfo, VkImageView, ViewHasher> m_viewsMap;
 	Mutex m_viewsMapMtx;
 	VkImageViewCreateInfo m_viewCreateInfoTemplate;
 	U64 m_uuid; ///< Steal the UUID from the Texture.

src/anki/scene/SceneGraph.h

@@ -234,7 +234,7 @@ private:
 
 	IntrusiveList<SceneNode> m_nodes;
 	U32 m_nodesCount = 0;
-	HashMap<CString, SceneNode*, CStringHasher, CStringCompare> m_nodesDict;
+	HashMap<CString, SceneNode*, CStringHasher> m_nodesDict;
 
 	SceneNode* m_mainCam = nullptr;
 	Timestamp m_activeCameraChangeTimestamp = getGlobalTimestamp();

src/anki/util/Forward.h

@@ -3,6 +3,8 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
+/// @file It contains forward declarations of util classes.
+
 #pragma once
 
 #include <anki/util/StdTypes.h>
@@ -13,4 +15,30 @@ namespace anki
 template<U N, typename TChunkType>
 class BitSet;
 
+template<typename T>
+class BitMask;
+
+template<typename, typename, typename>
+class HashMap;
+
+template<typename, typename, typename>
+class IntrusiveHashMap;
+
+template<typename T>
+class Hierarchy;
+
+template<typename T>
+class List;
+
+template<typename T>
+class ListAuto;
+
+template<typename T, typename TIndex>
+class SparseArray;
+
+class String;
+class StringAuto;
+
+class ThreadHive;
+
 } // end namespace anki

src/anki/util/HashMap.h

@@ -8,17 +8,11 @@
 #include <anki/util/Allocator.h>
 #include <anki/util/Functions.h>
 #include <anki/util/NonCopyable.h>
+#include <anki/util/Forward.h>
 
 namespace anki
 {
 
-// Forward
-template<typename, typename, typename, typename>
-class HashMap;
-
-template<typename, typename, typename, typename>
-class IntrusiveHashMap;
-
 /// @addtogroup util_containers
 /// @{
 
@@ -59,10 +53,10 @@ public:
 template<typename TNodePointer, typename TValuePointer, typename TValueReference>
 class HashMapIterator
 {
-	template<typename, typename, typename, typename>
+	template<typename, typename, typename>
 	friend class anki::HashMap;
 
-	template<typename, typename, typename, typename>
+	template<typename, typename, typename>
 	friend class anki::IntrusiveHashMap;
 
 public:
@@ -181,9 +175,8 @@ private:
 /// @tparam TKey The key of the map.
 /// @tparam TValue The value of the map.
 /// @tparam THasher Functor to hash type of TKey.
-/// @tparam TCompare Functor to compare TKey.
 /// @internal
-template<typename TKey, typename TValue, typename THasher, typename TCompare, typename TNode>
+template<typename TKey, typename TValue, typename THasher, typename TNode>
 class HashMapBase : public NonCopyable
 {
 public:
@@ -283,17 +276,6 @@ protected:
 
 } // end namespace detail
 
-/// Default hash key compare.
-template<typename TKey>
-class DefaultHashKeyCompare
-{
-public:
-	Bool operator()(const TKey& a, const TKey& b) const
-	{
-		return a == b;
-	}
-};
-
 /// Default hasher.
 template<typename TKey>
 class DefaultHasher
@@ -301,7 +283,7 @@ class DefaultHasher
 public:
 	U64 operator()(const TKey& a) const
 	{
-		return a.genHash();
+		return a.computeHash();
 	}
 };
 
@@ -317,14 +299,11 @@ public:
 };
 
 /// Hash map template.
-template<typename TKey,
-	typename TValue,
-	typename THasher = DefaultHasher<TKey>,
-	typename TCompare = DefaultHashKeyCompare<TKey>>
-class HashMap : public detail::HashMapBase<TKey, TValue, THasher, TCompare, detail::HashMapNode<TValue>>
+template<typename TKey, typename TValue, typename THasher = DefaultHasher<TKey>>
+class HashMap : public detail::HashMapBase<TKey, TValue, THasher, detail::HashMapNode<TValue>>
 {
 private:
-	using Base = detail::HashMapBase<TKey, TValue, THasher, TCompare, detail::HashMapNode<TValue>>;
+	using Base = detail::HashMapBase<TKey, TValue, THasher, detail::HashMapNode<TValue>>;
 	using Node = detail::HashMapNode<TValue>;
 
 public:
@@ -395,13 +374,13 @@ private:
 template<typename TClass>
 class IntrusiveHashMapEnabled : public NonCopyable
 {
-	template<typename TKey, typename TValue, typename THasher, typename TCompare, typename TNode>
+	template<typename TKey, typename TValue, typename THasher, typename TNode>
 	friend class detail::HashMapBase;
 
 	template<typename TNodePointer, typename TValuePointer, typename TValueReference>
 	friend class detail::HashMapIterator;
 
-	template<typename TKey, typename TValue, typename THasher, typename TCompare>
+	template<typename TKey, typename TValue, typename THasher>
 	friend class IntrusiveHashMap;
 
 	friend TClass;
@@ -453,14 +432,11 @@ private:
 
 /// Hash map that doesn't perform any allocations. To work the TValue nodes will have to inherit from
 /// IntrusiveHashMapEnabled.
-template<typename TKey,
-	typename TValue,
-	typename THasher = DefaultHasher<TKey>,
-	typename TCompare = DefaultHashKeyCompare<TKey>>
-class IntrusiveHashMap : public detail::HashMapBase<TKey, TValue, THasher, TCompare, TValue>
+template<typename TKey, typename TValue, typename THasher = DefaultHasher<TKey>>
+class IntrusiveHashMap : public detail::HashMapBase<TKey, TValue, THasher, TValue>
 {
 private:
-	using Base = detail::HashMapBase<TKey, TValue, THasher, TCompare, TValue>;
+	using Base = detail::HashMapBase<TKey, TValue, THasher, TValue>;
 	using Node = TValue;
 
 public:

src/anki/util/HashMap.inl.h

@@ -8,8 +8,8 @@ namespace anki
 namespace detail
 {
 
-template<typename TKey, typename TValue, typename THasher, typename TCompare, typename TNode>
-void HashMapBase<TKey, TValue, THasher, TCompare, TNode>::insertNode(TNode* node)
+template<typename TKey, typename TValue, typename THasher, typename TNode>
+void HashMapBase<TKey, TValue, THasher, TNode>::insertNode(TNode* node)
 {
 	if(ANKI_UNLIKELY(!m_root))
 	{
@@ -57,9 +57,9 @@ void HashMapBase<TKey, TValue, THasher, TCompare, TNode>::insertNode(TNode* node
 	} while(!done);
 }
 
-template<typename TKey, typename TValue, typename THasher, typename TCompare, typename TNode>
-typename HashMapBase<TKey, TValue, THasher, TCompare, TNode>::Iterator
-HashMapBase<TKey, TValue, THasher, TCompare, TNode>::find(const Key& key)
+template<typename TKey, typename TValue, typename THasher, typename TNode>
+typename HashMapBase<TKey, TValue, THasher, TNode>::Iterator HashMapBase<TKey, TValue, THasher, TNode>::find(
+	const Key& key)
 {
 	const U64 hash = THasher()(key);
 
@@ -86,9 +86,9 @@ HashMapBase<TKey, TValue, THasher, TCompare, TNode>::find(const Key& key)
 	return Iterator(node);
 }
 
-template<typename TKey, typename TValue, typename THasher, typename TCompare, typename TNode>
-typename HashMapBase<TKey, TValue, THasher, TCompare, TNode>::ConstIterator
-HashMapBase<TKey, TValue, THasher, TCompare, TNode>::find(const Key& key) const
+template<typename TKey, typename TValue, typename THasher, typename TNode>
+typename HashMapBase<TKey, TValue, THasher, TNode>::ConstIterator HashMapBase<TKey, TValue, THasher, TNode>::find(
+	const Key& key) const
 {
 	const U64 hash = THasher()(key);
 
@@ -115,8 +115,8 @@ HashMapBase<TKey, TValue, THasher, TCompare, TNode>::find(const Key& key) const
 	return ConstIterator(node);
 }
 
-template<typename TKey, typename TValue, typename THasher, typename TCompare, typename TNode>
-void HashMapBase<TKey, TValue, THasher, TCompare, TNode>::removeNode(TNode* del)
+template<typename TKey, typename TValue, typename THasher, typename TNode>
+void HashMapBase<TKey, TValue, THasher, TNode>::removeNode(TNode* del)
 {
 	ANKI_ASSERT(del);
 	TNode* parent = del->m_parent;
@@ -182,9 +182,9 @@ void HashMapBase<TKey, TValue, THasher, TCompare, TNode>::removeNode(TNode* del)
 
 } // end namespace detail
 
-template<typename TKey, typename TValue, typename THasher, typename TCompare>
+template<typename TKey, typename TValue, typename THasher>
 template<typename TAllocator>
-void HashMap<TKey, TValue, THasher, TCompare>::destroy(TAllocator alloc)
+void HashMap<TKey, TValue, THasher>::destroy(TAllocator alloc)
 {
 	if(Base::m_root)
 	{
@@ -193,9 +193,9 @@ void HashMap<TKey, TValue, THasher, TCompare>::destroy(TAllocator alloc)
 	}
 }
 
-template<typename TKey, typename TValue, typename THasher, typename TCompare>
+template<typename TKey, typename TValue, typename THasher>
 template<typename TAllocator>
-void HashMap<TKey, TValue, THasher, TCompare>::destroyInternal(TAllocator alloc, Node* node)
+void HashMap<TKey, TValue, THasher>::destroyInternal(TAllocator alloc, Node* node)
 {
 	ANKI_ASSERT(node);
 

src/anki/util/List.h

@@ -7,15 +7,12 @@
 
 #include <anki/util/Allocator.h>
 #include <anki/util/NonCopyable.h>
+#include <anki/util/Forward.h>
 #include <functional>
 
 namespace anki
 {
 
-// Forward
-template<typename T>
-class List;
-
 /// @addtogroup util_containers
 /// @{
 

src/anki/util/SparseArray.h

@@ -143,6 +143,7 @@ private:
 
 /// Sparse array.
 /// @tparam T The type of the valut it will hold.
+/// @tparam TIndex Indicates the max size of the sparse indices it can accept. Can be U32 or U64.
 template<typename T, typename TIndex = U32>
 class SparseArray
 {

src/anki/util/String.h

@@ -9,6 +9,7 @@
 #include <anki/util/Array.h>
 #include <anki/util/NonCopyable.h>
 #include <anki/util/Hash.h>
+#include <anki/util/Forward.h>
 #include <cstring>
 #include <cstdio>
 #include <cinttypes> // For PRId8 etc
@@ -16,10 +17,6 @@
 namespace anki
 {
 
-// Forward
-class String;
-class StringAuto;
-
 /// @addtogroup util_private
 /// @{
 

tests/util/HashMap.cpp

@@ -22,15 +22,6 @@ public:
 	}
 };
 
-class Compare
-{
-public:
-	Bool operator()(int a, int b)
-	{
-		return a == b;
-	}
-};
-
 ANKI_TEST(Util, HashMap)
 {
 	HeapAllocator<U8> alloc(allocAligned, nullptr);
@@ -39,7 +30,7 @@ ANKI_TEST(Util, HashMap)
 
 	// Simple
 	{
-		HashMap<int, int, Hasher, Compare> map;
+		HashMap<int, int, Hasher> map;
 		map.pushBack(alloc, 20, 1);
 		map.pushBack(alloc, 21, 1);
 		map.destroy(alloc);
@@ -47,7 +38,7 @@ ANKI_TEST(Util, HashMap)
 
 	// Add more and iterate
 	{
-		HashMap<int, int, Hasher, Compare> map;
+		HashMap<int, int, Hasher> map;
 
 		for(U i = 0; i < valsSize; ++i)
 		{
@@ -67,7 +58,7 @@ ANKI_TEST(Util, HashMap)
 
 	// Erase
 	{
-		HashMap<int, int, Hasher, Compare> map;
+		HashMap<int, int, Hasher> map;
 
 		for(U i = 0; i < valsSize; ++i)
 		{
@@ -76,7 +67,7 @@ ANKI_TEST(Util, HashMap)
 
 		for(U i = valsSize - 1; i != 0; --i)
 		{
-			HashMap<int, int, Hasher, Compare>::Iterator it = map.find(vals[i]);
+			HashMap<int, int, Hasher>::Iterator it = map.find(vals[i]);
 			ANKI_TEST_EXPECT_NEQ(it, map.getEnd());
 
 			map.erase(alloc, it);
@@ -88,7 +79,7 @@ ANKI_TEST(Util, HashMap)
 
 	// Find
 	{
-		HashMap<int, int, Hasher, Compare> map;
+		HashMap<int, int, Hasher> map;
 
 		for(U i = 0; i < valsSize; ++i)
 		{
@@ -97,7 +88,7 @@ ANKI_TEST(Util, HashMap)
 
 		for(U i = valsSize - 1; i != 0; --i)
 		{
-			HashMap<int, int, Hasher, Compare>::Iterator it = map.find(vals[i]);
+			HashMap<int, int, Hasher>::Iterator it = map.find(vals[i]);
 			ANKI_TEST_EXPECT_NEQ(it, map.getEnd());
 			ANKI_TEST_EXPECT_EQ(*it, vals[i] * 10);
 		}
@@ -108,7 +99,7 @@ ANKI_TEST(Util, HashMap)
 	// Fuzzy test
 	{
 		const U MAX = 1000;
-		HashMap<int, int, Hasher, Compare> akMap;
+		HashMap<int, int, Hasher> akMap;
 		std::vector<int> numbers;
 
 		// Insert random
@@ -151,7 +142,7 @@ ANKI_TEST(Util, HashMap)
 
 	// Bench it
 	{
-		using AkMap = HashMap<int, int, Hasher, Compare>;
+		using AkMap = HashMap<int, int, Hasher>;
 		AkMap akMap;
 		using StlMap =
 			std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, HeapAllocator<std::pair<int, int>>>;
@@ -285,7 +276,7 @@ ANKI_TEST(Util, IntrusiveHashMap)
 	Hashable b(2);
 	Hashable c(10);
 
-	IntrusiveHashMap<int, Hashable, Hasher, Compare> map;
+	IntrusiveHashMap<int, Hashable, Hasher> map;
 
 	// Add vals
 	map.pushBack(1, &a);