💿🐜 Antkeeper source code
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
423 lines
12 KiB
423 lines
12 KiB
/*
|
|
* 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;
|
|
}
|
|
|