inksoul
/
plumageRender
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

fix projectionMatrix

test-headless
ink-soul 2024-04-25 18:08:20 +08:00
parent 086c5987e3
commit 31e90a59cc
8 changed files with 216 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
base/camera.hpp
View File

@ -22,7 +22,8 @@ private:
void updateViewMatrix()
{
glm::mat4 rotM = glm::mat4(rotationMatrix);
glm::mat4 rotM =glm::transpose(rotationMatrix);
glm::mat4 transM;
/*
rotM = glm::rotate(rotM, glm::radians(rotation.x * (flipY ? -1.0f : 1.0f)), glm::vec3(1.0f, 0.0f, 0.0f));
@ -30,6 +31,7 @@ private:
rotM = glm::rotate(rotM, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
*/
glm::vec3 translation = position;
if (flipY) {
translation.y *= -1.0f;
}
@ -41,10 +43,12 @@ private:
}
else
{
matrices.view = LookAt(position, to, up, false, true);
matrices.view = transM * rotM ;
// matrices.view = transM * glm::inverse(glm::transpose(rotationMatrix));//LookAt(position, to, up, false, true);//transM * glm::transpose(glm::inverse(rotationMatrix));
//matrices.view = LookAt(position, to, up, false, true);
}
viewPos = glm::vec4(position, 0.0f) * glm::vec4(-1.0f, 1.0f, -1.0f, 1.0f);
//viewPos = glm::vec4(position, 0.0f) * glm::vec4(-1.0f, 1.0f, -1.0f, 1.0f);
updated = true;
};
@ -185,10 +189,12 @@ public:
if (zPositive)
{ // rightHand = true and zPositive = true, usually used in 3d reconstruction
yAxis = -yAxis;
}
else
{ // rightHand = true and zPositive = false, usually used in OpenGL
zAxis = -zAxis;
}
}
else
@ -209,15 +215,36 @@ public:
yAxis.x, yAxis.y, yAxis.z,
zAxis.x, zAxis.y, zAxis.z
);
//R = rotationMatrix;
R = glm::transpose(R); // Let's transpose it back
//R = glm::inverse(R);
glm::vec3 t = -R * from; // t = -R * from;
//R = glm::transpose(R);
/**/
glm::mat4 m = glm::mat4(
xAxis.x, xAxis.y, xAxis.z, t.x,
yAxis.x, yAxis.y, yAxis.z, t.y,
zAxis.x, zAxis.y, zAxis.z, t.z,
0, 0, 0, 1);
/*
glm::mat4 m = glm::mat4(
R[0][0], R[0][1], R[0][2], t.x,
R[1][0], R[1][1],R[1][2], t.y,
R[2][0], R[2][1],R[2][2], t.z,
0, 0, 0, 1);
glm::mat4 m = glm::mat4(
1, 0, 0,0 ,
0, 1, 0,0 ,
0, 0, 1, 0,
0, 0, 0, 1);
*/
m = glm::transpose(m); // Let's transpose it back
//m = glm::inverse(m);
return m;
}
@ -229,11 +256,11 @@ public:
this->znear = znear;
this->zfar = zfar;
float A = -(zfar + znear) / (znear - zfar);
float B = 2 * (zfar * znear) / (znear - zfar);
float B = -2 * (zfar * znear) / (znear - zfar);
glm::mat4 persepctive = glm::mat4(glm::vec4(fx / cx, 0, 0, 0),
glm::vec4(0, fy / cy, 0, 0),
glm::vec4(0, 0, A, B),
glm::vec4(0, 0, 1, 0));
glm::vec4(0, 0, -1, 0));
matrices.perspective = persepctive;
}

46
base/renderConfig.cpp
View File

@ -39,7 +39,7 @@ void PlumageConfig::PlumageConfiguration::readConfigurationFromToml(std::string
//settings.cleanUpImageSequece = toml::find_or<bool>(debug, "cleanUpImageSequece");
/*
conversion: type and coordinate system(rotation had been converted)
conversion: type and coordinate system
*/
size_t sz;
@ -56,19 +56,47 @@ void PlumageConfig::PlumageConfiguration::readConfigurationFromToml(std::string
for (uint64_t i = 0; i < cameraTracksAndAngleSize; i++)
{
settings.cameraTracks[i] = glm::vec3(cameraTracks[i][0], -cameraTracks[i][1], -cameraTracks[i][2]);
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]),
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;
glm::vec3 cameraTracksVecA = settings.cameraTracks[cameraTracksAndAngleSize / 4] - settings.cameraTracks[0];
glm::vec3 cameraTracksVecB = settings.cameraTracks[cameraTracksAndAngleSize / 2] - settings.cameraTracks[0] ;
glm::vec3 cameraTracksCircleNormal = glm::cross(cameraTracksVecA, cameraTracksVecB);
glm::mat4 cameraTracksRotionMatrix = getVectorRotationMatrix(cameraTracksVecA, cameraTracksVecB);
for (uint64_t i = 0; i < cameraTracksAndAngleSize; i++)
{
settings.cameraTracks[i] = settings.cameraTracks[i] * cameraTracksRotionMatrix;
}
//float ratioX =(float)settings.width / (float)settings.calibrationWidth;
//float ratioY = (float)settings.height / (float)settings.calibrationHeight;
//settings.fX = settings.fX * ratioX;
//settings.fY = settings.fY * ratioY;
//settings.cX = settings.cX * ratioX;
//settings.cY = settings.cY * ratioY;
}
glm::mat4 PlumageConfig::PlumageConfiguration::getVectorRotationMatrix(glm::vec3 vectorBefore, glm::vec3 vectorAfter)
{
glm::vec3 rotationAxis = glm::normalize(glm::cross(glm::vec3(0.f, 1.f, 0.f), 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()

20
base/renderConfig.h
View File

@ -3,7 +3,20 @@
#include <filesystem>
#include <fstream>
#include <iostream>
#ifndef GLM_FORCE_RADIANS
#define GLM_FORCE_RADIANS
#endif
#ifndef GLM_FORCE_DEPTH_ZERO_TO_ONE
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#endif
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <toml/toml.hpp>
#include <vulkan/vulkan.h>
@ -77,7 +90,7 @@ namespace PlumageConfig
struct FilePath
{ //model path
std::string glTFModelFilePath = getAssetPath() + "models/free_porsche_911_carrera_4s.glb";
std::string glTFModelFilePath = getAssetPath() + "models/classic_round_side_table.glb";
std::string modelVertShaderPath = getAssetPath() + "buster_drone/shaders/glsl/mesh.vert.spv";
std::string modelFragShaderPath = getAssetPath() + "buster_drone/shaders/glsl/mesh.frag.spv";
@ -131,7 +144,7 @@ namespace PlumageConfig
std::string hdr2ktxShFilePath = getAssetPath() + "script/hdr2ktxShFilePath.sh";
// 配置文件路径，命令行传入后保存在这
//std::string configFilePath = getAssetPath() + "config/guanzi.toml";
std::string configFilePath = getAssetPath() + "config/yukino_flat.toml";
std::string configFilePath = getAssetPath() + "config/yukino_original_coord.toml";
} filePath;
@ -141,6 +154,9 @@ namespace PlumageConfig
void convertIntToVkSampleCount(uint32_t sampleCount);
glm::mat4 getVectorRotationMatrix(glm::vec3 vectorBefore, glm::vec3 vectorAfter);
PlumageConfiguration();
~PlumageConfiguration();

7
base/vulkanexamplebase.cpp
View File

@ -338,6 +338,13 @@ void VulkanExampleBase::renderLoop()
camera.setPosition(settings.cameraTracks[currentFrame]);
camera.setRotation(settings.cameraAngle[currentFrame]);
for (uint32_t i = 95; i < 120; i++)
{
glm::vec3 b = settings.cameraTracks[i];
glm::mat3 c = settings.cameraAngle[i];
}
renderFrame();
currentFrame++;
if (currentFrame>=settings.cameraAngle.size()-1)

39
data/config/yukino_original_coord.toml 100644
View File

File diff suppressed because one or more lines are too long

10
data/config/yukino_traj1_matrix.toml
View File

File diff suppressed because one or more lines are too long

102
src/render/render.cpp
View File

@ -1489,6 +1489,37 @@ PlumageRender::PlumageRender()
uniformBuffer.skybox.create(vulkanDevice, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, sizeof(shaderDataSkybox));
uniformBuffer.params.create(vulkanDevice, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, sizeof(shaderData));
}
float modelSize = std::max(models.scene.aabb[0][0], std::max(models.scene.aabb[1][1], models.scene.aabb[2][2]));
// Center and scale model
float scale = (1.0f / modelSize) * 0.5f;//(1.0f / modelSize ) *
glm::vec3 modelCenter = -glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
modelCenter += glm::vec3(models.scene.aabb[3][0], models.scene.aabb[3][1], models.scene.aabb[3][2]);
modelCenter = 0.5f * modelCenter;
modelCenter += glm::vec3(0, 0.5f * models.scene.aabb[3][1] - models.scene.aabb[1][1], 0);
glm::vec3 translate = settings.bottomCenter - modelCenter ;
glm::vec3 vecA = glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
glm::vec3 vecB = glm::vec3(models.scene.aabb[3][0], models.scene.aabb[1][1], models.scene.aabb[3][2]);
glm::vec3 vecC = glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[3][2]);
glm::vec3 modelTopNormal = glm::cross(vecB - vecA, vecB - vecC);
modelTopNormal = glm::normalize(modelTopNormal);
glm::vec4 modelTopNormal4 = glm::vec4(modelTopNormal,1.f);
modelTopNormal4 = glm::transpose(glm::inverse(shaderDataScene.model)) * modelTopNormal4;
shaderDataScene.model = glm::translate(glm::mat4(1.0f), modelCenter);
shaderDataScene.model = glm::translate(shaderDataScene.model, translate);
glm::vec3 modelTopNormal3 = glm::vec3(modelTopNormal4);
glm::vec3 rotationAxis = glm::normalize(glm::cross(glm::vec3(0.f,1.f,0.f), modelTopNormal3));
float cosTheta = glm::dot(settings.bottomNormal, modelTopNormal3);
float angle = acos(cosTheta);
angle = angle * M_PI / 180;
shaderDataScene.model = glm::rotate(shaderDataScene.model, angle, rotationAxis);
updateUniformBuffers();
}
@ -1497,38 +1528,54 @@ PlumageRender::PlumageRender()
// Scene
shaderDataScene.projection = camera.matrices.perspective;
shaderDataScene.view = camera.matrices.view;
//shaderDataScene.model = glm::mat4(1.0f);
float modelSize = std::max(models.scene.aabb[0][0], std::max(models.scene.aabb[1][1], models.scene.aabb[2][2]));
// Center and scale model
float scale = (1.0f / modelSize ) * 5.0f;
//glm::vec3 translate = -glm::vec3(models.scene.aabb[3][0], models.scene.aabb[3][1], models.scene.aabb[3][2]);
//translate += -glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
//translate += -2.0f * settings.bottomCenter;
//camera.setPosition(glm::vec3(0, 0, -modelSize - 2));
glm::vec3 aabbMax = glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
glm::vec3 aabbMin = glm::vec3(models.scene.aabb[3][0], models.scene.aabb[3][1], models.scene.aabb[3][2]);
glm::vec3 modelCenter = 0.5f * (aabbMin + aabbMax);
//glm::vec3 aabbMax = glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
//glm::vec3 aabbMin = glm::vec3(models.scene.aabb[3][0], models.scene.aabb[3][1], models.scene.aabb[3][2]);
//glm::vec3 modelCenter = 0.5f * (aabbMin + aabbMax);
//glm::vec3 modelCenter = glm::vec3(0, 2,0 );
//modelCenter = glm::vec3(modelCenter[0], 2.0f * modelCenter[1], modelCenter[2]);
glm::vec3 vecA = glm::vec3(-12.8401, 13.892, 26.7971);
glm::vec3 vecB = glm::vec3(13.3531, 13.9043, 26.8202);
glm::vec3 vecC = glm::vec3(13.1931, 13.8983, -26.0002);
//glm::vec3 vecA = glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2])
//glm::vec3 vecA = glm::vec3(models.scene.aabb[0], models.scene.aabb[1], models.scene.aabb[2]);
//glm::vec3 vecA = glm::vec3(models.scene.aabb[3][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
//glm::vec3 vecB = glm::vec3(models.scene.aabb[])
glm::vec3 translate = settings.cameraFixation - modelCenter;
//glm::vec4 topNormal = glm::vec4(glm::cross(vecA - vecB, vecA - vecC), 0.0f);
//topNormal = glm::normalize(topNormal);
//glm::vec3 modelCenterVector = 0.5f * (vecA - vecB);
//glm::vec3 modelCenter = glm::vec3(0.5f * (vecA[0] + vecB[0]), vecA[1], 0.5f * (vecC[2] + vecB[2]));
//glm::vec3 modelCenter = glm::vec3(0.5f * modelCenterVector[0], vecA[1], 0.5f * modelCenterVector[2]);
//glm::vec3 faceNormal = normalize(cross(vertices[face[1]].position - vertices[face[0]].position, vertices[face[2]].position - vertices[face[0]].position));
//glm::vec4 modelTopNormal4 = glm::transpose(glm::inverse(shaderDataScene.model)) * topNormal;
//glm::vec3 modelTopNormal3 = glm::vec3(modelTopNormal4[0], modelTopNormal4[1], modelTopNormal4[2]);
//shaderDataScene.model = glm::translate(shaderDataScene.model, translate);
//models.scene.getSceneDimensions();
//translate = modelCenter + translate ;
//shaderDataScene.model = glm::translate(glm::mat4(1.0f), translate);
//glm::vec3 translate = settings.cameraFixation;
shaderDataScene.model = glm::scale(glm::mat4(1.0f), glm::vec3(scale, scale, scale));
//shaderDataScene.model = glm::scale(glm::mat4(1.0f), glm::vec3(scale, scale, scale));
//glm::mat4 scaleModelMatrix = glm::scale(glm::mat4(1.0f),glm::vec3(scale,scale,scale));
//glm::mat4 translateMatrix = glm::translate(glm::mat4(1.0f), translate);
shaderDataScene.model = glm::translate(glm::mat4(1.0f), modelCenter);
shaderDataScene.model = glm::translate(shaderDataScene.model, translate);
//shaderDataScene.model = glm::scale()
glm::mat4 rotationMatrix = glm::mat4(1.0f);
glm::vec4 topNormal = glm::vec4(0,1,0,0);
glm::vec4 modelTopNormal4 = glm::transpose(glm::inverse(shaderDataScene.model)) * topNormal;
glm::vec3 modelTopNormal3 = glm::vec3(modelTopNormal4[0], modelTopNormal4[1], modelTopNormal4[2]);
glm::vec3 rotationAxis = glm::normalize(glm::cross(settings.bottomNormal, modelTopNormal3));
float cosTheta = glm::dot(settings.bottomNormal, modelTopNormal3);
float angle = acos(cosTheta);
shaderDataScene.model = glm::rotate(glm::mat4(1.0f), angle, rotationAxis);
//shaderDataScene.model = glm::scale()
//auto modelMatrix = glm::translate(glm::mat4(0.0f), -modelCenter) * glm::translate(glm::mat4(0.0f), translate) * glm::scale(glm::mat4(1.0f), glm::vec3(scale, scale, scale));
//glm::vec3 bottomVec1 = glm::vec3(models.scene.aabb[0][0])
//glm::mat4 rotationMatrix = glm::mat4(1.0f);
//glm::vec4 topNormal4 = glm::vec4(topNormal, 0.0f);
//glm::vec4 topNormal = glm::vec4(0,0,1,0);
/*
shaderDataScene.camPos = glm::vec3(
-camera.position.z * sin(glm::radians(camera.rotation.y)) * cos(glm::radians(camera.rotation.x)),
@ -1552,6 +1599,7 @@ PlumageRender::PlumageRender()
// Skybox
shaderDataSkybox.projection = camera.matrices.perspective;
shaderDataSkybox.view = camera.matrices.view;
//shaderDataSkybox.model = ;
shaderDataSkybox.model = glm::mat4(glm::mat3(camera.matrices.view));
}
@ -1573,11 +1621,12 @@ PlumageRender::PlumageRender()
VulkanExampleBase::prepare();
camera.type = Camera::CameraType::lookat;
camera.setProjectionMatrix(settings.fX,settings.fY,settings.cX,settings.cY,1.f, 256.f,settings.calibrationWidth,settings.calibrationHeight,false,true);
//camera.setPerspective(settings.fX, settings.fY, settings.cX, settings.cY, 1.0f, 256.0f);
//camera.setPerspective(glm::radians(45.f), settings.width / settings.height, 1.f, 256.f);
camera.setProjectionMatrix(settings.fX,settings.fY,settings.cX,settings.cY,1.f, 256.f,settings.width,settings.height,false,true);
//camera.setPerspective(settings.fX, settings.fY, settings.cX, settings.cY, 0.1f, 100.0f);
camera.setTo(settings.cameraFixation);
camera.setUp(glm::vec3(0.f,1.f,0.f));
//camera.setUp(glm::vec3(0.f,1.f,0.f));
camera.setUp(glm::vec3(0.f,1.f,1.f));
camera.rotationSpeed = 0.25f;
camera.movementSpeed = 0.1f;
@ -1648,6 +1697,7 @@ PlumageRender::PlumageRender()
vkDestroyFence(device, fence, nullptr);
}
// todo :根据physicalDeviceIndex确定子文件夹路径，frameIndex确定fileName
void PlumageRender::writeImageToFile(std::string filePath)
{

2
src/render/render.h
View File

@ -300,6 +300,8 @@ public:
void prepare();
void submitWork(VkCommandBuffer cmdBuffer, VkQueue queue);
void getRotationMatrix(glm::vec3 before, glm::vec3 after);
void writeImageToFile(std::string filePath);
void outputImageSequence();
void imageSequenceToVideo();