plumageRender/base/renderConfig.cpp

#include "renderConfig.h"



void PlumageConfig::PlumageConfiguration::readConfigurationFromToml(std::string configFilePath,Settings& settings)
{
	auto config = toml::parse(configFilePath);
	
	auto& tomlSettings = toml::find(config, "settings");
	
	settings.width = toml::find<uint32_t>(tomlSettings, "width");
	settings.height = toml::find<uint32_t>(tomlSettings, "height");
	settings.multiSampling = toml::find<bool>(tomlSettings, "multiSampling");
	auto sampleCount = toml::find<uint32_t>(tomlSettings, "sampleCount");
	settings.rotateModel = toml::find<bool>(tomlSettings, "rotateModel");
	settings.modelRotateSpeed = toml::find<float>(tomlSettings, "modelRotateSpeed");
	settings.startFrameIndex = toml::find<uint32_t>(tomlSettings, "startFrameIndex");
	settings.endFrameIndex = toml::find<uint32_t>(tomlSettings, "endFrameIndex");
	settings.videoFrameRate = toml::find<uint32_t>(tomlSettings, "videoFrameRate");
	auto& camera = toml::find(tomlSettings, "camera");
	settings.calibrationWidth = toml::find<int>(camera, "cam_width");
	settings.calibrationHeight = toml::find<int>(camera, "cam_height");
	std::string fX = toml::find<std::string>(camera, "fx");
	std::string fY = toml::find<std::string>(camera, "fy");
	std::string cX = toml::find<std::string>(camera, "cX");
	std::string cY = toml::find<std::string>(camera, "cY");
	std::vector<float> bottomCenter = toml::find<std::vector<float>>(camera, "bottomCenter");
	std::vector<float> bottomNormal = toml::find<std::vector<float>>(camera, "bottomNormal");
	std::vector<float> cameraFixation = toml::find<std::vector<float>>(camera, "center");
	std::vector<std::vector<float>> cameraTracks = toml::find<std::vector<std::vector<float>>>(camera, "cameraTracks");
	std::vector<std::vector<std::vector<float>>> cameraAngle = toml::find<std::vector<std::vector<std::vector<float>>>>(camera, "cameraAngle");
	
	auto& debug = toml::find(tomlSettings, "debug");
	settings.validation = toml::find<bool>(debug, "validation");
	settings.vsync = toml::find<bool>(debug, "vsync");
	settings.headless = toml::find<bool>(debug, "headless");
	settings.outputPNGimage = toml::find<bool>(debug, "outputPNGimage");
	settings.debugMode = toml::find<bool>(debug, "debugMode");
	//settings.cleanUpImageSequece = toml::find_or<bool>(debug, "cleanUpImageSequece");

	/*
		conversion: type and coordinate system(rotation had been converted)
	*/

	size_t sz;
	settings.fX = std::stof(fX, &sz);
	settings.fY = std::stof(fY, &sz);
	settings.cX = std::stof(cX, &sz);
	settings.cY = std::stof(cY, &sz);
	settings.bottomCenter = glm::vec3(bottomCenter[0], -bottomCenter[1], -bottomCenter[2]);
	settings.bottomNormal = glm::vec3(bottomNormal[0], -bottomNormal[1], -bottomNormal[2]);
	settings.cameraFixation = glm::vec3(cameraFixation[0], -cameraFixation[1], -cameraFixation[2]);
	auto cameraTracksAndAngleSize = std::min(cameraTracks.size(), cameraAngle.size());
	settings.cameraTracks.resize(cameraTracksAndAngleSize);
	settings.cameraAngle.resize(cameraTracksAndAngleSize);
	
	for (uint64_t i = 0; i < cameraTracksAndAngleSize; i++)
	{
		settings.cameraTracks[i] = glm::vec3(cameraTracks[i][0], -cameraTracks[i][1], -cameraTracks[i][2]);
		
		settings.cameraAngle[i] = glm::mat3(glm::vec3(cameraAngle[i][0][0], cameraAngle[i][0][1], cameraAngle[i][0][2]),
											glm::vec3(cameraAngle[i][1][0], cameraAngle[i][1][1], cameraAngle[i][1][2]),
											glm::vec3(cameraAngle[i][2][0], cameraAngle[i][2][1], cameraAngle[i][2][2]));
		
	}
	float ratioX = settings.width / settings.calibrationWidth;
	float ratioY = settings.height / settings.calibrationWidth;
	settings.fX = settings.fX * ratioX;
	settings.fY = settings.fY * ratioY;
	settings.cX = settings.cX * ratioX;
	settings.cY = settings.cY * ratioY;
}

PlumageConfig::PlumageConfiguration::PlumageConfiguration()
{
	
	readConfigurationFromToml(filePath.configFilePath, settings);
	
}

PlumageConfig::PlumageConfiguration::~PlumageConfiguration()
{
}