Initial commit: Final state of the master project

2017-09-16 09:41:37 +02:00
commit 696180d43b
832 changed files with 169717 additions and 0 deletions
--- a/Research/scene/PoolBuilder/StandardPoolBuilder.cpp
+++ b/Research/scene/PoolBuilder/StandardPoolBuilder.cpp
@@ -0,0 +1,135 @@
+#include "StandardPoolBuilder.h"
+#include <algorithm>
+#include "../../inc/tbb/parallel_sort.h"
+
+std::string StandardPoolBuilder::GetFullFileName(const std::string& fileName) const
+{
+	return fileName + ".s.pool";
+}
+
+std::vector<unsigned8> StandardPoolBuilder::GetPointerSizesPerLevel(const BaseTree* tree) const
+{
+	unsigned8 depth = tree->GetMaxLevel();
+	std::vector<unsigned8> res(depth + 1);
+	res[depth] = 0; // Pointers in the leafs have size 0;
+	for (unsigned8 level = depth; level > 0; level--)
+	{
+		unsigned8 bytesPerPointer = res[level];
+		size_t requiredBytesNextLevel = 0;
+		for (unsigned32 i = 0; i < (unsigned32)tree->GetNodeCount(); i++)
+		{
+			auto node = tree->GetNode(i);
+			if (node->GetLevel() == level)
+				requiredBytesNextLevel += GetBaseNodeSize(tree, i) + node->GetChildCount() * bytesPerPointer;
+		}
+		res[level - 1] = BitHelper::RoundToBytes(std::max<unsigned8>(1, BitHelper::Log2Ceil(requiredBytesNextLevel))) / 8;
+	}
+	for (unsigned8 level = 0; level <= depth; level++)
+		printf("Pointers in level %u: %u bytes\n", level, res[level]);
+	return res;
+}
+
+void StandardPoolBuilder::CalculatePointerSizesPerLevel(const BaseTree* tree)
+{
+	assert(tree != NULL);
+	mPointerSizesPerLevel = GetPointerSizesPerLevel(tree);
+}
+
+void StandardPoolBuilder::InitBuild(const BaseTree* tree) 
+{
+	CalculatePointerSizesPerLevel(tree); 
+	mIsBuildingTree = true;
+}
+void StandardPoolBuilder::FinishBuild(const BaseTree* tree)
+{
+	ClearVariables();
+	mIsBuildingTree = false;
+}
+
+unsigned8 StandardPoolBuilder::GetBytesPerPointer(const BaseTree* tree, const unsigned32& nodeIndex) const
+{
+	const Node* node = tree->GetNode(nodeIndex);
+	if (node->GetLevel() == 0) return 0;
+	return mPointerSizesPerLevel[node->GetLevel() - 1];
+}
+
+size_t StandardPoolBuilder::GetPoolInfoSize(const BaseTree* tree) const
+{
+	assert(tree != NULL);
+	unsigned8 depth = tree->GetMaxLevel();
+	return (depth + 1) * 4 // Leave some space for the level offsets (32 bits = 4 bytes per level),
+		+ (depth + 1);	   // Space for the size of the node pointers
+}
+
+std::vector<unsigned8> StandardPoolBuilder::GetPoolInfo(const BaseTree* tree, const std::vector<size_t>& nodePointers, const std::vector<unsigned32>& nodeOrder)
+{
+		//// Go through the level (in order), keeping track of the indices
+	//for (unsigned8 level = 0; level <= depth; level++)
+	//{
+	//	auto levelStart = levelIndices[level];
+	//	auto levelEnd = levelIndices[level + 1];
+	//	levelOffsets[level] = (unsigned32)curIndex;
+	//	for (auto i = levelStart; i < levelEnd; i++)
+	//	{
+	//		Node* node = tree->GetNode(nodeOrder[i]);
+	//		nodePointers[node->GetIndex()] = curIndex - levelOffsets[level];
+	//		assert(level == 0 || nodePointers[node->GetIndex()] < BitHelper::Exp2(bytesPerPointer[level - 1] * 8)); // Assert the index fits
+	//		curIndex += 1 + additionalBytesPerNode[level] + node->GetChildCount() * (bytesPerPointer[level] + additionalBytesPerPointer[level]);
+	//	}
+	//}
+	mLevelOffsets = std::vector<unsigned32>(tree->GetMaxLevel() + 1);
+	unsigned8 curLevel = 255;
+	for (size_t i = 0; i < tree->GetNodeCount(); i++)
+	{
+		unsigned32 nodeId = nodeOrder[i];
+		const Node* node = tree->GetNode(nodeId);
+		if (node->GetLevel() != curLevel)
+		{
+			curLevel++;
+			mLevelOffsets[curLevel] = (unsigned32)nodePointers[nodeId];
+		}
+	}
+
+	std::vector<unsigned8> res(GetPoolInfoSize(tree));
+	size_t curIndex = 0;
+	// Write the level offsets
+	for (unsigned8 level = 0; level <= tree->GetMaxLevel(); level++)
+	{
+		BitHelper::SplitInBytesAndMove(mLevelOffsets[level], res, curIndex);
+		curIndex += 4;
+	}
+
+	// Write the number of bytes per pointer
+	for (unsigned8 level = 0; level <= tree->GetMaxLevel(); level++)
+		res[curIndex++] = mPointerSizesPerLevel[level];
+	return res;
+}
+
+std::vector<unsigned8> StandardPoolBuilder::WrapPointer(const BaseTree* tree, const unsigned32& nodeIndex, const unsigned32& indexInPool, const unsigned32& pointer) const
+{
+	const Node* node = tree->GetNode(nodeIndex);
+	unsigned8 nodeLevel = node->GetLevel();
+	unsigned32 withinLevelPointer = pointer - mLevelOffsets[nodeLevel];
+	return BitHelper::SplitInBytes(withinLevelPointer, mPointerSizesPerLevel[nodeLevel - 1]);
+}
+
+void StandardPoolBuilder::ClearVariables()
+{
+	mPointerSizesPerLevel.clear();
+	mLevelOffsets.clear();
+}
+
+//void StandardPoolBuilder::OrderNodes(const BaseTree* tree, std::vector<unsigned32>& nodeOrder) const
+//{
+//	std::vector<size_t> parentCounts = tree->GetParentCounts();
+//	// First order on level (asc), then on number of parents (desc), so that the most used nodes have the smallest pointers
+//	tbb::parallel_sort(nodeOrder.begin(), nodeOrder.end(), [tree, parentCounts](const unsigned32& i1, const unsigned32& i2)
+//	{
+//		Node* a = tree->GetNode(i1);
+//		Node* b = tree->GetNode(i2);
+//		if (a->GetLevel() != b->GetLevel()) return a->GetLevel() < b->GetLevel();
+//		if (parentCounts[i1] != parentCounts[i2]) return parentCounts[i1] > parentCounts[i2];
+//		// If the level and number of parents is the same, then, for consistency, order on nodeID.
+//		return i1 < i2;
+//	});
+//}