terrain loader and eterrain

Author: benjamaan476

.clang-tidy

@@ -32,6 +32,8 @@ FormatStyle:     none
 CheckOptions:
   - key: readability-identifier-length.IgnoredVariableNames
     value: 'x|y|z'
+  - key: readability-identifier-length.IgnoredLoopCounterNames
+    value: '^[ijk_xyz]$'
   - key: readability-identifier-length.IgnoredParameterNames
     value: 'x|y|z'
 

assets/scenes/test_scene.ess

@@ -43,4 +43,5 @@ quadratic=0.44
 
 [Terrain]
 name=test_terrain
+resource_name=test_terrain
 [/Terrain]

assets/terrains/test_terrain.eterrain

@@ -0,0 +1,7 @@
+# Test terrain file
+version=1.0
+
+heightmap=GreyScaleElevation
+scale_x=1
+scale_y=1
+scale_z=100

assets/textures/GreyScaleElevation.png

@@ -29,6 +29,7 @@ set(SOURCES
     loaders/shader_loader.cpp
     loaders/system_font_loader.cpp
     loaders/text_loader.cpp
+    loaders/terrain_loader.cpp
     log/log.cpp
     platform/platform.cpp
     platform/filesystem.cpp

engine/CMakeLists.txt

@@ -10,7 +10,7 @@ namespace egkr
 
     resource::shared_ptr mesh_loader::load(const std::string& name, void* /*params*/)
     {
-	egkr::vector<supported_file_type> file_types{{.extension=".esm", .file_type=mesh_file_type::esm, .is_binary=true}, {.extension=".obj", .file_type=mesh_file_type::obj, .is_binary=false}};
+	egkr::vector<supported_file_type> file_types{{.extension = ".esm", .file_type = mesh_file_type::esm, .is_binary = true}, {.extension = ".obj", .file_type = mesh_file_type::obj, .is_binary = false}};
 
 	bool found{};
 	supported_file_type found_type{};
@@ -362,11 +362,11 @@ namespace egkr
 
 	properties.vertices = malloc(size);
 
+	generate_tangents(vertices, properties.indices);
 	std::copy(vertices.data(), vertices.data() + properties.vertex_count, (vertex_3d*)properties.vertices);
 
 	properties.center = (properties.extents.min + properties.extents.max) / 2.F;
 
-	generate_tangents(properties.vertices, properties.indices);
 
 	return properties;
     }

engine/loaders/mesh_loader.cpp

@@ -276,6 +276,9 @@ namespace egkr
 		case parse_mode::mesh:
 		    current_mesh.resource_name = value;
 		    break;
+		case parse_mode::terrain:
+		    current_terrain.resource_name = value;
+		    break;
 		default:
 		    break;
 		}

engine/loaders/scene_loader.cpp

@@ -0,0 +1,125 @@
+#include "terrain_loader.h"
+
+#include "log/log.h"
+#include "platform/filesystem.h"
+#include "resources/resource.h"
+#include "resources/terrain.h"
+#include "systems/resource_system.h"
+#include <map>
+
+namespace egkr::loader
+{
+    terrain::unique_ptr terrain::create(const loader_properties& properties) { return std::make_unique<terrain>(properties); }
+
+    terrain::terrain(const loader_properties& properties): resource_loader{resource::type::terrain, properties} { }
+
+    resource::shared_ptr terrain::load(const std::string& name, void* /* params */)
+    {
+	const auto base_path = get_base_path();
+	const std::string filename = std::format("{}/{}{}", base_path, name, ".eterrain");
+
+	const auto properties = load_configuration_file(filename);
+
+	resource::properties resource_properties{.type = get_loader_type(), .name = name, .full_path = filename, .data = new egkr::terrain::properties()};
+
+	resource_properties.data = new egkr::terrain::configuration();
+	*(egkr::terrain::configuration*)resource_properties.data = properties;
+
+	return resource::create(resource_properties);
+    }
+
+    bool terrain::unload(const resource::shared_ptr& resource)
+    {
+	delete (egkr::terrain::configuration*)resource->data;
+	resource->data = nullptr;
+	return true;
+    }
+
+    static const std::map<std::string, std::function<void(egkr::terrain::configuration&, const std::string&)>> terrain_configuration_members = {
+        {"version", [](egkr::terrain::configuration& /* config */, const std::string& /* value */) noexcept {}},
+        {"heightmap", [](egkr::terrain::configuration& config, const std::string& value) noexcept { config.heightmap = value; }},
+        {"tiles_x", [](egkr::terrain::configuration& config, const std::string& value) noexcept { config.tiles_x = (uint32_t)std::stoi(value); }},
+        {"tiles_y", [](egkr::terrain::configuration& config, const std::string& value) noexcept { config.tiles_y = (uint32_t)std::stoi(value); }},
+        {"scale_x", [](egkr::terrain::configuration& config, const std::string& value) noexcept { config.scale_x = std::stof(value); }},
+        {"scale_y", [](egkr::terrain::configuration& config, const std::string& value) noexcept { config.scale_y = std::stof(value); }},
+        {"scale_z", [](egkr::terrain::configuration& config, const std::string& value) noexcept { config.scale_z = std::stof(value); }},
+    };
+
+    egkr::terrain::configuration terrain::load_configuration_file(const std::string& path)
+    {
+	egkr::terrain::configuration properties{};
+
+	auto handle = filesystem::open(path, file_mode::read, false);
+	if (!handle.is_valid)
+	{
+	    LOG_ERROR("Failed to open terrain file {}", path);
+	    return {};
+	}
+
+	auto line = filesystem::read_line(handle, 511);
+	uint32_t line_number{};
+	for (; !line.empty(); line = filesystem::read_line(handle, 511), ++line_number)
+	{
+	    std::string line_string{line.begin(), line.end()};
+	    trim(line_string);
+
+	    if (line[0] == '#' || line[0] == '\0')
+	    {
+		continue;
+	    }
+
+	    auto split_index = line_string.find_first_of('=');
+	    if (split_index == std::string::npos)
+	    {
+		LOG_WARN("Potential formatting issue found in file {}, '=' token not found on line number {}.", path, line_number);
+		continue;
+	    }
+
+	    auto variable_name = line_string.substr(0, split_index);
+	    trim(variable_name);
+
+	    auto value = line_string.substr(split_index + 1);
+	    trim(value);
+
+	    if (!terrain_configuration_members.contains(variable_name))
+	    {
+		LOG_WARN("Unrecognised terrain configuration arguement: {}", variable_name);
+		continue;
+	    }
+	    terrain_configuration_members.at(variable_name)(properties, value);
+	}
+
+	if (properties.heightmap != "")
+	{
+	    image_resource_parameters params{.flip_y = false};
+	    auto heightmap_image = resource_system::load(properties.heightmap, resource::type::image, &params);
+	    if (!heightmap_image || !heightmap_image->data)
+	    {
+		LOG_ERROR("Could not load heightmap image: {}", properties.heightmap);
+	    }
+	    else
+	    {
+		auto* image_properties = (texture::properties*)heightmap_image->data;
+		const auto* pixels = (uint8_t*)image_properties->data;
+		properties.tiles_x = image_properties->width;
+		properties.tiles_y = image_properties->height;
+
+		const uint32_t count = properties.tiles_x * properties.tiles_y;
+		properties.height_data.reserve(count);
+		for (uint32_t i{}; i < 4 * count; i += 4)
+		{
+		    const auto r = pixels[i + 0];
+		    const auto g = pixels[i + 1];
+		    const auto b = pixels[i + 2];
+
+		    const float sum = (r + g + b) / (3.f * 255);
+		    properties.height_data.push_back(sum);
+		}
+
+		egkr::resource_system::unload(heightmap_image);
+	    }
+	}
+
+	return properties;
+    }
+}

engine/loaders/terrain_loader.cpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "resource_loader.h"
+#include "resources/terrain.h"
+
+namespace egkr::loader
+{
+    class terrain : public resource_loader
+    {
+    public:
+	using unique_ptr = std::unique_ptr<terrain>;
+	static unique_ptr create(const loader_properties& properties);
+
+	explicit terrain(const loader_properties& properties);
+	terrain(const terrain&) = delete;
+	terrain operator=(const terrain&) = delete;
+	terrain(terrain&&) = delete;
+	terrain operator=(terrain&&) = delete;
+
+	~terrain() override = default;
+
+	resource::shared_ptr load(const std::string& name, void* params) override;
+	bool unload(const resource::shared_ptr& resource) override;
+    private:
+	egkr::terrain::configuration load_configuration_file(const std::string& path);
+    };
+}

engine/loaders/terrain_loader.h

@@ -123,8 +123,11 @@ namespace egkr::pass
 
 	    for (const auto& terrain : data.terrain)
 	    {
-		const auto& world = terrain.transform.lock()->get_world();
-		shader_system::set_uniform(terrain_shader_locations.model, &world);
+		if (const auto& world = terrain.transform.lock())
+		{
+		    const auto& model = world->get_world();
+		    shader_system::set_uniform(terrain_shader_locations.model, &model);
+		};
 	    }
 
 	    if (data.terrain.front().is_winding_reversed)