scene_levels.cpp

#include "template.h"
#include "Noise.h"
#include "scene.h"
#include "Edit.h"

Level* Scene::AddLevel(std::string name)
{
	m_levels.emplace_back(name);
	return GetLevelByIndexSafe(m_levels.size() - 1);
}

void Tmpl8::Scene::ApplyEdits(const std::vector<std::unique_ptr<Edit>>& edits)
{
#pragma omp parallel for
	for (int x = 0; x < WORLDSIZE; x++)
	{
		for (int y = 0; y < WORLDSIZE; y++)
		{
			for (int z = 0; z < WORLDSIZE; z++)
			{
                const int3 worldPos = int3(x, y, z);
                const float3 relPos = make_float3(worldPos) / float(WORLDSIZE);
                Material::ID_T mat = GetVoxelAt(x, y, z).m_materialIndex;
				for (const auto& edit : edits)
				{
					mat = edit->Evaluate(worldPos, relPos, mat);
				}
				Set(x, y, z, Voxel{ mat });
			}
		}
	}

	BuildChunks();
}

Level* Scene::GetLevelByIndexSafe(size_t index)
{
	if (index < 0 || index >= m_levels.size())
	{
		return nullptr;
	}

	return &m_levels[index];
}

Level* Scene::GetCurrentLevelRW()
{
	static Level* cached = nullptr;
	static size_t cachedID = 0;
	const size_t index = GetSettingsR().m_currentLevelIndex;
	if (cached == nullptr || cachedID != index)
	{
		cachedID = index;
		cached = &m_levels[index];
	}
	return cached;
}

const Level* const Scene::GetCurrentLevelR() const
{
	static const Level* cached = nullptr;
	static size_t cachedID = 0;
	const size_t index = GetSettingsR().m_currentLevelIndex;
	if (cached == nullptr || cachedID != index)
	{
		cachedID = index;
		cached = &m_levels[index];
	}
	return cached;
}

size_t Scene::GetCurrentLevelIndex() const
{
	return GetSettingsR().m_currentLevelIndex;
}

size_t Scene::GetLevelsCount() const
{
	return m_levels.size();
}

void Scene::TryLoadLevelSafe(size_t index)
{
	if (index < 0 || index >= m_levels.size())
	{
		return;
	}

	UnloadCurrentLevel();

	GetSettingsRW().m_currentLevelIndex = index;
	Level* level = GetCurrentLevelRW();
	auto output = Level::Outputs{ *this, level };
	level->Load(Level::Inputs{}, output);

	m_LevelMaterialManager = &level->m_materialManager;
	m_hasSpheres_cache = level->m_hasSpheres;
	BuildChunks();
}

void Scene::ReloadCurrentLevel()
{
	TryLoadLevelSafe(GetCurrentLevelIndex());
}

void Tmpl8::Scene::LoadRandomLevel()
{
	size_t length = GetLevelsCount();

	if (length == 0)
	{
		return;
	}

	size_t index = Noise::SimpleWhite::GetNext<size_t>(Noise::Config().MinMax(0.0f, static_cast<float>(length)));

	if (index >= length)
	{
		index = length - 1;
	}

	TryLoadLevelSafe(index);
}

void Scene::UnloadCurrentLevel()
{
	m_LevelMaterialManager = nullptr;
	memset(grid, 0, sizeof(grid));
}