source/src/resources/material-loader.cpp

/*
 * Copyright (C) 2020  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "renderer/material.hpp"
#include "resource-loader.hpp"
#include "resource-manager.hpp"
#include "rasterizer/shader-variable-type.hpp"
#include "rasterizer/texture-wrapping.hpp"
#include "rasterizer/texture-filter.hpp"
#include "rasterizer/texture-2d.hpp"
#include "string-table.hpp"
#include <cctype>
#include <vector>
#include <map>

static const std::map<std::string, texture_wrapping> texture_wrapping_map =
{
	{"clamp", texture_wrapping::clamp},
	{"repeat", texture_wrapping::repeat},
	{"mirrored_repeat", texture_wrapping::mirrored_repeat},
};

static const std::map<std::string, texture_min_filter> texture_min_filter_map =
{
	{"nearest", texture_min_filter::nearest},
	{"linear", texture_min_filter::linear},
	{"nearest_mipmap_nearest", texture_min_filter::nearest_mipmap_nearest},
	{"linear_mipmap_nearest", texture_min_filter::linear_mipmap_nearest},
	{"nearest_mipmap_linear", texture_min_filter::nearest_mipmap_linear},
	{"linear_mipmap_linear", texture_min_filter::linear_mipmap_linear}
};

static const std::map<std::string, texture_mag_filter> texture_mag_filter_map =
{
	{"nearest", texture_mag_filter::nearest},
	{"linear", texture_mag_filter::linear},
};

static bool load_bool_property(material* material, const string_table_row& row, int vector_size, int array_size)
{
	if (row.size() - 4 != vector_size * array_size || vector_size < 1 || vector_size > 4)
	{
		return false;
	}

	std::size_t size = array_size * vector_size;
	bool* values = new bool[size];
	for (std::size_t i = 0; i < size; ++i)
	{
		values[i] = (std::stoi(row[4 + i]) != 0);
	}

	if (vector_size == 1)
	{
		material_property<bool>* property = material->add_property<bool>(row[1], array_size);
		property->set_values(0, values, array_size);
	}
	else if (vector_size == 2)
	{
		material_property<bool2>* property = material->add_property<bool2>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const bool2*>(values), array_size);
	}
	else if (vector_size == 3)
	{
		material_property<bool3>* property = material->add_property<bool3>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const bool3*>(values), array_size);
	}
	else if (vector_size == 4)
	{
		material_property<bool4>* property = material->add_property<bool4>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const bool4*>(values), array_size);
	}

	delete[] values;

	return true;
}

static bool load_int_property(material* material, const string_table_row& row, int vector_size, int array_size)
{
	if (row.size() - 4 != vector_size * array_size || vector_size < 1 || vector_size > 4)
	{
		return false;
	}

	std::size_t size = array_size * vector_size;
	int* values = new int[size];
	for (std::size_t i = 0; i < size; ++i)
	{
		values[i] = std::stoi(row[4 + i]);
	}

	if (vector_size == 1)
	{
		material_property<int>* property = material->add_property<int>(row[1], array_size);
		property->set_values(0, values, array_size);
	}
	else if (vector_size == 2)
	{
		material_property<int2>* property = material->add_property<int2>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const int2*>(values), array_size);
	}
	else if (vector_size == 3)
	{
		material_property<int3>* property = material->add_property<int3>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const int3*>(values), array_size);
	}
	else if (vector_size == 4)
	{
		material_property<int4>* property = material->add_property<int4>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const int4*>(values), array_size);
	}

	delete[] values;

	return true;
}

static bool load_uint_property(material* material, const string_table_row& row, int vector_size, int array_size)
{
	if (row.size() - 4 != vector_size * array_size || vector_size < 1 || vector_size > 4)
	{
		return false;
	}

	std::size_t size = array_size * vector_size;
	unsigned int* values = new unsigned int[size];
	for (std::size_t i = 0; i < size; ++i)
	{
		values[i] = static_cast<unsigned int>(std::stoul(row[4 + i]));
	}

	if (vector_size == 1)
	{
		material_property<unsigned int>* property = material->add_property<unsigned int>(row[1], array_size);
		property->set_values(0, values, array_size);
	}
	else if (vector_size == 2)
	{
		material_property<uint2>* property = material->add_property<uint2>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const uint2*>(values), array_size);
	}
	else if (vector_size == 3)
	{
		material_property<uint3>* property = material->add_property<uint3>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const uint3*>(values), array_size);
	}
	else if (vector_size == 4)
	{
		material_property<uint4>* property = material->add_property<uint4>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const uint4*>(values), array_size);
	}

	delete[] values;

	return true;
}

static bool load_float_property(material* material, const string_table_row& row, int vector_size, int array_size)
{
	if (row.size() - 4 != vector_size * array_size || vector_size < 1 || vector_size > 4)
	{
		return false;
	}

	std::size_t size = array_size * vector_size;
	float* values = new float[size];
	for (std::size_t i = 0; i < size; ++i)
	{
		values[i] = static_cast<float>(std::stod(row[4 + i]));
	}

	if (vector_size == 1)
	{
		material_property<float>* property = material->add_property<float>(row[1], array_size);
		property->set_values(0, values, array_size);
	}
	else if (vector_size == 2)
	{
		material_property<float2>* property = material->add_property<float2>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const float2*>(values), array_size);
	}
	else if (vector_size == 3)
	{
		material_property<float3>* property = material->add_property<float3>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const float3*>(values), array_size);
	}
	else if (vector_size == 4)
	{
		material_property<float4>* property = material->add_property<float4>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const float4*>(values), array_size);
	}

	delete[] values;

	return true;
}

static bool load_float_matrix_property(material* material, const string_table_row& row, int matrix_columns, int matrix_rows, int array_size)
{
	int matrix_size = matrix_columns * matrix_rows;

	if (row.size() - 4 != matrix_size * array_size)
	{
		return false;
	}

	std::size_t size = array_size * matrix_size;
	float* values = new float[size];
	for (std::size_t i = 0; i < size; ++i)
	{
		values[i] = static_cast<float>(std::stod(row[4 + i]));
	}

	if (matrix_size == 2*2)
	{
		material_property<float2x2>* property = material->add_property<float2x2>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const float2x2*>(values), array_size);
	}
	else if (matrix_size == 3*3)
	{
		material_property<float3x3>* property = material->add_property<float3x3>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const float3x3*>(values), array_size);
	}
	else if (matrix_size == 4*4)
	{
		material_property<float4x4>* property = material->add_property<float4x4>(row[1], array_size);
		property->set_values(0, reinterpret_cast<const float4x4*>(values), array_size);
	}

	delete[] values;

	return true;
}

static bool load_texture_2d_property(material* material, const string_table_row& row, resource_manager* resource_manager, int array_size)
{
	if (row.size() - 4 != array_size * 6)
	{
		return false;
	}

	const texture_2d** values = new const texture_2d*[array_size];
	for (std::size_t i = 0; i < array_size; ++i)
	{
		std::size_t offset = 4 + i;

		const std::string& filename = row[offset];
		texture_wrapping wrap_s = texture_wrapping::clamp;
		texture_wrapping wrap_t = texture_wrapping::clamp;
		texture_min_filter min_filter = texture_min_filter::linear_mipmap_linear;
		texture_mag_filter mag_filter = texture_mag_filter::linear;
		if (auto it = texture_wrapping_map.find(row[offset + 1]); it != texture_wrapping_map.end())
		{
			wrap_s = it->second;
		}
		if (auto it = texture_wrapping_map.find(row[offset + 2]); it != texture_wrapping_map.end())
		{
			wrap_t = it->second;
		}
		if (auto it = texture_min_filter_map.find(row[offset + 3]); it != texture_min_filter_map.end())
		{
			min_filter = it->second;
		}
		if (auto it = texture_mag_filter_map.find(row[offset + 4]); it != texture_mag_filter_map.end())
		{
			mag_filter = it->second;
		}
		float max_anisotropy = static_cast<float>(std::stod(row[offset + 5]));

		texture_2d* texture = resource_manager->load<texture_2d>(row[4 + i]);
		texture->set_wrapping(wrap_s, wrap_t);
		texture->set_filters(min_filter, mag_filter);
		texture->set_max_anisotropy(max_anisotropy);

		values[i] = texture;
	}
	
	material_property<const texture_2d*>* property = material->add_property<const texture_2d*>(row[1], array_size);
	property->set_values(0, values, array_size);

	delete[] values;

	return true;
}

static bool load_texture_cube_property(material* material, const string_table_row& row, resource_manager* resource_manager, int array_size)
{
	return false;
}

static bool load_material_property(material* material, const string_table_row& row, resource_manager* resource_manager)
{
	// Ensure row has at least five columns
	if (row.size() < 5)
	{
		return false;
	}

	const std::string& name = row[1];
	if (name.empty())
	{
		return false;
	}

	const std::string& type = row[2];
	if (type.empty())
	{
		return false;
	}

	int vector_size = 1;
	if (std::isdigit(type.back()))
	{
		vector_size = std::stoi(type.substr(type.size() - 1, 1));
	}

	int matrix_columns = 0;
	int matrix_rows = 0;
	if (type[type.size() - 2] == 'x' && std::isdigit(type[type.size() - 3]) && std::isdigit(type.back()))
	{
		matrix_columns = std::stoi(type.substr(type.size() - 3, 1));
		matrix_rows = std::stoi(type.substr(type.size() - 1, 1));
	}

	int array_size = std::stoi(row[3]);
	if (array_size <= 0)
	{
		return false;
	}

	if (type == "bool" || type == "bool2" || type == "bool3" || type == "bool4")
	{
		return load_bool_property(material, row, vector_size, array_size);
	}
	else if (type == "int" || type == "int2" || type == "int3" || type == "int4")
	{
		return load_int_property(material, row, vector_size, array_size);
	}
	else if (type == "uint" || type == "uint2" || type == "uint3" || type == "uint4")
	{
		return load_uint_property(material, row, vector_size, array_size);
	}
	else if (type == "float" || type == "float2" || type == "float3" || type == "float4")
	{
		return load_float_property(material, row, vector_size, array_size);
	}
	else if (type == "float2x2" || type == "float3x3" || type == "float4x4")
	{
		return load_float_matrix_property(material, row, matrix_columns, matrix_rows, array_size);
	}
	else if (type == "texture_2d")
	{
		return load_texture_2d_property(material, row, resource_manager, array_size);
	}
	else if (type == "texture_cube")
	{
		return load_texture_cube_property(material, row, resource_manager, array_size);
	}

	return false;
}

template <>
material* resource_loader<material>::load(resource_manager* resource_manager, PHYSFS_File* file)
{
	// Load string table from input stream
	string_table* table = resource_loader<string_table>::load(resource_manager, file);

	// Ensure table is not empty.
	if (!table || table->empty())
	{
		delete table;
		return nullptr;
	}

	// Allocate material
	::material* material = new ::material();

	// Parse table rows
	for (const string_table_row& row: *table)
	{
		// Skip empty rows and comments
		if (row.empty() || row[0].empty() || row[0][0] == '#')
		{
			continue;
		}

		if (row[0] == "shader" && row.size() == 2)
		{
			shader_program* program = resource_manager->load<shader_program>(row[1]);
			material->set_shader_program(program);
		}
		else if (row[0] == "flags" && row.size() == 2)
		{
			std::uint32_t flags = std::stoi(row[1]);
			material->set_flags(flags);
		}
		else if (row[0] == "property")
		{
			load_material_property(material, row, resource_manager);
		}
	}
	
	return material;
}