192 lines
8.0 KiB
C++
192 lines
8.0 KiB
C++
#include "renderConfig.h"
|
|
|
|
|
|
|
|
void PlumageConfig::PlumageConfiguration::readConfigurationFromToml(std::string configFilePath,Settings& settings)
|
|
{
|
|
/*
|
|
parse config file
|
|
*/
|
|
auto config = toml::parse(configFilePath);
|
|
|
|
// get settings
|
|
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");
|
|
|
|
/*
|
|
get settings.camera
|
|
*/
|
|
|
|
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> pedestledModelTopCenter = toml::find<std::vector<float>>(camera, "pedestledModelTopCenter");
|
|
std::vector<float> bottomCenter = toml::find<std::vector<float>>(camera, "bottomCenter");
|
|
std::vector<int> bottomNormal = toml::find<std::vector<int>>(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");
|
|
|
|
/*
|
|
get settings.debug
|
|
*/
|
|
|
|
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");
|
|
|
|
/*
|
|
get filePath
|
|
*/
|
|
|
|
auto& tomlFilePath = toml::find(config, "FilePath");
|
|
|
|
//gltf model path
|
|
filePath.glTFModelFilePath = setFilePathFromToml(tomlFilePath, "glTFModelFilePath");
|
|
filePath.envMapFilePath = setFilePathFromToml(tomlFilePath,"envMapFilePath");
|
|
filePath.imageOutputPath = setFilePathFromToml(tomlFilePath, "imageOutputPath");
|
|
filePath.videoOutputPath = setFilePathFromToml(tomlFilePath, "videoOutputPath");
|
|
//filePath. = setFilePathFromToml(tomlFilePath, );
|
|
//filePath. = setFilePathFromToml(tomlFilePath, );
|
|
//filePath. = setFilePathFromToml(tomlFilePath, );
|
|
//filePath.imageOutputPath = setFilePathFromToml(tomlFilePath, "imageOutputPath");
|
|
//filePath.videoOutputPath = setFilePathFromToml(tomlFilePath, "videoOutputPath");
|
|
|
|
/*
|
|
conversion: type and coordinate system
|
|
*/
|
|
|
|
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]);
|
|
std::vector<glm::vec3> cameraTrackToFixation;
|
|
auto cameraTracksAndAngleSize = std::min(cameraTracks.size(), cameraAngle.size());
|
|
settings.cameraTracks.resize(cameraTracksAndAngleSize);
|
|
settings.cameraAngle.resize(cameraTracksAndAngleSize);
|
|
cameraTrackToFixation.resize(cameraTracksAndAngleSize);
|
|
for (uint64_t i = 0; i < cameraTracksAndAngleSize; i++)
|
|
{
|
|
settings.cameraTracks[i] = glm::vec3(cameraTracks[i][0], -cameraTracks[i][1] , cameraTracks[i][2]);
|
|
cameraTrackToFixation[i] = settings.cameraTracks[i] - settings.bottomCenter;
|
|
|
|
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]));
|
|
|
|
|
|
}
|
|
|
|
glm::vec3 cameraTracksVecA = settings.cameraTracks[cameraTracksAndAngleSize / 4] - settings.cameraTracks[0];
|
|
glm::vec3 cameraTracksVecB = settings.cameraTracks[cameraTracksAndAngleSize / 2] - settings.cameraTracks[0] ;
|
|
//glm::vec3 cameraTrackFixation = settings.cameraTracks[cameraTracksAndAngleSize / 4] - settings.cameraFixation;
|
|
|
|
|
|
glm::vec3 cameraTracksCircleNormal = glm::normalize( glm::cross(cameraTracksVecA, cameraTracksVecB));
|
|
glm::vec3 rotationAxis = glm::normalize(glm::cross(cameraTracksCircleNormal, glm::vec3(0.f, 1.f, 0.f)));
|
|
float rotationAngle = acos(glm::dot(cameraTracksCircleNormal, glm::vec3(0.f, 1.f, 0.f)));
|
|
glm::mat4 cameraTracksRotationMatrix = glm::rotate(glm::mat4(1.f), rotationAngle, rotationAxis);
|
|
settings.cameraFixation = cameraTracksRotationMatrix * glm::vec4(settings.cameraFixation, 1.0f);
|
|
settings.bottomCenter = cameraTracksRotationMatrix * glm::vec4(settings.bottomCenter, 1.0f);
|
|
|
|
glm::vec3 translate =glm::vec3(0.f,0.f,0.f) - settings.bottomCenter;
|
|
glm::mat4 trans = glm::mat4(1.0f);
|
|
trans = glm::translate(trans, translate);
|
|
settings.cameraFixation = trans * glm::vec4(settings.cameraFixation, 1.0f);
|
|
for (uint64_t i = 0; i < cameraTracksAndAngleSize; i++)
|
|
{
|
|
cameraTrackToFixation[i] = cameraTracksRotationMatrix * glm::vec4(cameraTrackToFixation[i], 1.0f);
|
|
cameraTrackToFixation[i] = trans * glm::vec4(cameraTrackToFixation[i], 1.0f);
|
|
cameraTrackToFixation[i] = glm::vec3(std::truncf(cameraTrackToFixation[i][0] * 10000) / 10000, std::truncf(cameraTrackToFixation[i][1] * 10000)/10000, std::truncf(cameraTrackToFixation[i][2] * 10000)/10000);
|
|
settings.cameraTracks[i] = settings.bottomCenter + cameraTrackToFixation[i] ;
|
|
settings.cameraAngle[i] = cameraTracksRotationMatrix * glm::mat4(settings.cameraAngle[i]) ;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/**/
|
|
|
|
std::string PlumageConfig::PlumageConfiguration::setFilePathFromToml(toml::value & tomlValue,std::string tomlValueName)
|
|
{
|
|
std::string filePathFromToml = toml::find<std::string>(tomlValue,tomlValueName);
|
|
std::string pattern = "https?://[a-zA-Z0-9-]+\\.cos\\.ap-guangzhou\\.myqcloud\\.com";
|
|
std::regex urlRegex(pattern);
|
|
std::filesystem::path filesystemConfigFilePath ;
|
|
if (std::regex_search(filePathFromToml,urlRegex))
|
|
{
|
|
filesystemConfigFilePath = filePathFromToml;
|
|
return filesystemConfigFilePath.generic_string();
|
|
}
|
|
else
|
|
{
|
|
if (std::filesystem::exists(filesystemConfigFilePath))
|
|
{
|
|
return filesystemConfigFilePath.generic_string();
|
|
}
|
|
else
|
|
{
|
|
std::filesystem::path assetPath = getAssetPath();
|
|
assetPath += filesystemConfigFilePath;
|
|
if (std::filesystem::exists(assetPath))
|
|
{
|
|
return assetPath.generic_string();
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
glm::vec3 PlumageConfig::PlumageConfiguration::getTranslatedVector(glm::vec3 currentVector,glm::vec3 targetVector)
|
|
{
|
|
glm::vec3 translate = glm::vec3(0.f,0.f,0.f) - targetVector;
|
|
glm::mat4 trans = glm::mat4(1.0f);
|
|
trans = glm::translate(trans, translate);
|
|
return glm::vec3(trans * glm::vec4(currentVector, 1.0f));
|
|
}
|
|
|
|
glm::mat4 PlumageConfig::PlumageConfiguration::getVectorRotationMatrix(glm::vec3 vectorBefore, glm::vec3 vectorAfter)
|
|
{
|
|
glm::vec3 rotationAxis = glm::normalize(glm::cross(vectorAfter, vectorBefore));
|
|
float cosTheta = glm::dot(vectorAfter, vectorBefore);
|
|
float angle = acos(cosTheta);
|
|
angle = angle * M_PI / 180;
|
|
glm::mat4 resultMatix = glm::rotate(glm::mat4(1.0f), angle, rotationAxis);
|
|
}
|
|
|
|
PlumageConfig::PlumageConfiguration::PlumageConfiguration()
|
|
{
|
|
|
|
readConfigurationFromToml(filePath.configFilePath, settings);
|
|
|
|
}
|
|
|
|
PlumageConfig::PlumageConfiguration::~PlumageConfiguration()
|
|
{
|
|
} |