LOD.cpp

#include "template.h"
#include "scene.h"
#include "LOD.h"

LOD::LOD(int depth)
	: m_depth(depth)
{
	assert(depth > 0 && depth < 10);

	m_side = 1 << depth;               // 2^depth
	m_count = size_t(m_side) * m_side * m_side;

	m_mask.resize(m_count, false);
	m_sphereIDs.resize(m_count);
}

void Scene::BuildChunks()
{
	m_LODDepth_cache = GetSettingsR().m_LODDepth;
	m_lods.clear();
	for (int d = 0; d < m_LODDepth_cache; ++d)
	{
		m_lods.emplace_back(d + 1); // depth grows from 1 to m_LODDepth
	}
	for (int d = m_LODDepth_cache; d >= 1; --d) // we build LODs from the last (finest) to the first (roughest)
	{
		LOD& lod = m_lods[d - 1];
		if (d == m_LODDepth_cache)
		{
			lod.BuildFromScene(*this);
		}
		else
		{
			lod.BuildFromPrevious(m_lods[d]);
		}
	}
}

void LOD::ClearAll()
{
	std::fill(m_mask.begin(), m_mask.end(), false);
}

void LOD::BuildFromScene(const Scene& scene)
{
	ClearAll();
	const Level* const level = scene.GetCurrentLevelR();

	const int blockSize = WORLDSIZE / m_side;

	for (int z = 0; z < m_side; z++)
	{
		for (int y = 0; y < m_side; y++)
		{
			for (int x = 0; x < m_side; x++)
			{
				bool occupied = false;
				int startX = x * blockSize;
				int startY = y * blockSize;
				int startZ = z * blockSize;

				for (int bz = 0; bz < blockSize && !occupied; bz++)
				{
					for (int by = 0; by < blockSize && !occupied; by++)
					{
						for (int bx = 0; bx < blockSize; bx++)
						{
							if (scene.GetVoxelAt(
								startX + bx,
								startY + by,
								startZ + bz).IsEmpty() == false)
							{
								occupied = true;
								break;
							}
						}
					}
				}

				if (occupied)
					Set(x, y, z);
			}
		}
	}

	// spheres

	float3 side3f = float3(static_cast<float>(m_side));
	int3 side3i = int3(m_side);

	static constexpr float RADIUS_EPS = 0.025f;
	for (size_t id = 0; id < level->m_spheres.objects.size(); ++id)
	{
		assert(id <= 0xffff && "Only unsigned short number of spheres is supported");
		const Sphere& sphere = level->m_spheres.objects[id];
		const float3 center = sphere.m_center;
		const float radius = sphere.m_radius;
		const float sqrRadius = radius * radius;
		const int3 minCell = clamp(int3((center - float3(radius + RADIUS_EPS)) * float(m_side)), int3(0), side3i);
		const int3 maxCell = clamp(int3((center + float3(radius + RADIUS_EPS)) * float(m_side)) + int3(1 /*to ensure round up*/), int3(0), side3i);
		for (int x = minCell.x; x < maxCell.x; ++x)
		{
			for (int y = minCell.y; y < maxCell.y; ++y)
			{
				for (int z = minCell.z; z < maxCell.z; ++z)
				{
					const float3 posf = float3(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
					const float3 cellMin = posf / side3f;
					const float3 cellMax = (posf + float3(1.0f)) / side3f;

					// Closest point on the cell AABB to the sphere center
					const float3 closest = clamp(center, cellMin, cellMax);

					if (sqrLength(closest - center) <= sqrRadius)
					{
						MarkSphere(x, y, z, static_cast<unsigned short>(id));
					}
				}
			}
		}
	}
}

void LOD::BuildFromPrevious(const LOD& finer)
{
	assert(finer.m_side == m_side * 2);

	ClearAll();

	for (int z = 0; z < m_side; z++)
	{
		for (int y = 0; y < m_side; y++)
		{
			for (int x = 0; x < m_side; x++)
			{
				const int fx = x * 2;
				const int fy = y * 2;
				const int fz = z * 2;
				const size_t index = Index(x, y, z);

				const size_t base = finer.Index(fx, fy, fz);
				const size_t offsetY = finer.m_side;
				const size_t offsetZ = finer.m_side * finer.m_side;

				const size_t finerIndices[8]{
					base,
					base + 1,
					base + offsetY,
					base + offsetY + 1,
					base + offsetZ,
					base + offsetZ + 1,
					base + offsetZ + offsetY,
					base + offsetZ + offsetY + 1
				};

				for (int i = 0; i < 8; i++)
				{
					const size_t finerIndex = finerIndices[i];
					if (finer.m_mask[finerIndex])
					{
						Set(x, y, z);
					}
					std::vector<unsigned short>& thisIDs = m_sphereIDs[index];
					const std::vector<unsigned short>& finerIDs = finer.m_sphereIDs[finerIndex];
					if (!finerIDs.empty())
					{
						for (auto sphereid : finer.m_sphereIDs[finerIndex])
						{
							if (std::find(thisIDs.begin(), thisIDs.end(), sphereid) == thisIDs.end()) // avoid repetitions
							{
								thisIDs.push_back(sphereid);
							}
						}
					}
				}
			}
		}
	}
}