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

camera roation error exist

test-headless
ink-soul 2024-04-26 18:22:30 +08:00
parent 31e90a59cc
commit d67df39ef1
5 changed files with 115 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
base/camera.hpp
View File

@ -22,7 +22,7 @@ private:
void updateViewMatrix()
{
glm::mat4 rotM =glm::transpose(rotationMatrix);
glm::mat4 rotM =rotationMatrix;
glm::mat4 transM;
/*
@ -43,9 +43,10 @@ private:
}
else
{
matrices.view = transM * rotM ;
//matrices.view = lookAt(position, lookAtPoint);
//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);
matrices.view = LookAt(position, lookAtPoint, up, false, true);
}
//viewPos = glm::vec4(position, 0.0f) * glm::vec4(-1.0f, 1.0f, -1.0f, 1.0f);
@ -59,8 +60,7 @@ public:
glm::vec3 rotation = glm::vec3();
glm::vec3 position = glm::vec3();
glm::vec4 viewPos = glm::vec4();
glm::vec3 from = glm::vec3();
glm::vec3 to = glm::vec3();
glm::vec3 lookAtPoint = glm::vec3();
glm::vec3 up = glm::vec3();
glm::mat4 rotationMatrix = glm::mat4();
@ -98,9 +98,9 @@ public:
return zfar;
}
void setTo(glm::vec3 to)
void setLookAtPoint(glm::vec3 lookAtPoint)
{
this->to = to;
this->lookAtPoint = lookAtPoint;
}
void setUp(glm::vec3 up)
@ -174,9 +174,9 @@ public:
glm::mat4 LookAt(const glm::vec3& from, const glm::vec3& to, const glm::vec3& up, bool zPositive, bool rightHand)
{
this->from = from;
this->to = to;
this->up = up;
//this->position = from;
//this->lookAtPoint = to;
//this->up = up;
// we stands on "from" and look at "to"
// if zPositive = true, the destination is in the area of the positive half-axis of z, otherwise it is negative
// if rightHand = true, the coordinate system is right-handed, otherwise it is left-handed
@ -229,10 +229,10 @@ public:
zAxis.x, zAxis.y, zAxis.z, t.z,
0, 0, 0, 1);
/*
//R = glm::transpose(R);
glm::mat4 m = glm::mat4(
R[0][0], R[0][1], R[0][2], t.x,
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);
@ -248,6 +248,22 @@ public:
return m;
}
glm::mat4 lookAt(glm::vec3 position, glm::vec3 lookAtPoint)
{
glm::vec3 translate = position - this->position;
glm::vec3 forward = glm::normalize(lookAtPoint - position);
glm::vec3 right = glm::normalize(glm::cross(glm::vec3(0, 1, 0), forward));
glm::vec3 up = glm::cross(forward, right);
glm::mat4 rotationMatrix = glm::mat4(glm::vec4(right, 0.0f),
glm::vec4(up, 0.0f),
glm::vec4(-forward, 0.0f),
glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
glm::mat4 viewMatrix = glm::translate(rotationMatrix, translate);
this->position = position;
return viewMatrix;
}
/*
GDC2007·½°¸£ºKoshy George
*/

48
base/renderConfig.cpp
View File

@ -59,29 +59,47 @@ void PlumageConfig::PlumageConfiguration::readConfigurationFromToml(std::string
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]));
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::cross(cameraTracksVecA, cameraTracksVecB);
glm::mat4 cameraTracksRotionMatrix = getVectorRotationMatrix(cameraTracksVecA, cameraTracksVecB);
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++)
{
settings.cameraTracks[i] = settings.cameraTracks[i] * cameraTracksRotionMatrix;
settings.cameraTracks[i] = trans * glm::vec4(settings.cameraTracks[i], 1.0f);
settings.cameraTracks[i] = cameraTracksRotationMatrix * glm::vec4( settings.cameraTracks[i],1.0f) ;
settings.cameraTracks[i] = glm::vec3(settings.cameraTracks[i][0], -settings.cameraTracks[i][1], settings.cameraTracks[i][2]);
settings.cameraAngle[i] = cameraTracksRotationMatrix * glm::mat4(settings.cameraAngle[i]) ;
}
//translate = settings.bottomCenter - ;
//trans = glm::translate(trans, translate);
//settings.bottomNormal = cameraTracksRotationMatrix * glm::vec4(settings.bottomNormal, 1.0f);
//float ratioX =(float)settings.width / (float)settings.calibrationWidth;
//float ratioY = (float)settings.height / (float)settings.calibrationHeight;
//settings.fX = settings.fX * ratioX;
@ -90,9 +108,17 @@ void PlumageConfig::PlumageConfiguration::readConfigurationFromToml(std::string
//settings.cY = settings.cY * ratioY;
}
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(glm::vec3(0.f, 1.f, 0.f), vectorBefore));
glm::vec3 rotationAxis = glm::normalize(glm::cross(vectorAfter, vectorBefore));
float cosTheta = glm::dot(vectorAfter, vectorBefore);
float angle = acos(cosTheta);
angle = angle * M_PI / 180;

4
base/renderConfig.h
View File

@ -78,7 +78,7 @@ namespace PlumageConfig
uint32_t height = 720;
bool multiSampling = false; // 多重采样
uint32_t sampleCount = VK_SAMPLE_COUNT_4_BIT; // 多重采样倍率
bool rotateModel = true; // Ä£ÐÍ×ÔÐýת
bool rotateModel = false; // Ä£ÐÍ×ÔÐýת
float modelRotateSpeed = 2.0f; // 自旋转速度
uint32_t startFrameIndex = 1; // 图片序列开始帧
uint32_t endFrameIndex = 50; // 图片序列结束帧
@ -154,6 +154,8 @@ namespace PlumageConfig
void convertIntToVkSampleCount(uint32_t sampleCount);
glm::vec3 getTranslatedVector(glm::vec3 beforeVector, glm::vec3 afterVector);
glm::mat4 getVectorRotationMatrix(glm::vec3 vectorBefore, glm::vec3 vectorAfter);

6
base/vulkanexamplebase.cpp
View File

@ -338,11 +338,7 @@ 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();

77
src/render/render.cpp
View File

@ -1490,35 +1490,35 @@ PlumageRender::PlumageRender()
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]));
//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);
//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 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);
//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, settings.bottomCenter);
//shaderDataScene.model = glm::scale(shaderDataScene.model, scale);
//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();
}
@ -1528,19 +1528,30 @@ PlumageRender::PlumageRender()
// Scene
shaderDataScene.projection = camera.matrices.perspective;
shaderDataScene.view = camera.matrices.view;
//shaderDataScene.model = glm::mat4(1.0f);
//shaderDataScene.model = glm::mat4();
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) * modelSize;
glm::vec3 translate = -glm::vec3(models.scene.aabb[3][0], models.scene.aabb[3][1], models.scene.aabb[3][2]);
translate += -0.5f * glm::vec3(models.scene.aabb[0][0], models.scene.aabb[1][1], models.scene.aabb[2][2]);
//glm::vec3 translate = glm::vec3(0.f, 0.f, 0.f);
//camera.setPosition(glm::vec3(0, 0, -modelSize - 2));
shaderDataScene.model = glm::mat4(1.0f);
shaderDataScene.model[0][0] = scale;
shaderDataScene.model[1][1] = scale;
shaderDataScene.model[2][2] = scale;
//shaderDataScene.model = glm::translate(shaderDataScene.model, translate);
//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 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(-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]);
@ -1595,7 +1606,7 @@ PlumageRender::PlumageRender()
//shaderDataScene.model = rotationMatrix * scaleModelMatrix;
shaderDataScene.camPos = settings.cameraTracks[currentFrame];
shaderDataScene.model = selfRotationMatrix;
//shaderDataScene.model = selfRotationMatrix;
// Skybox
shaderDataSkybox.projection = camera.matrices.perspective;
shaderDataSkybox.view = camera.matrices.view;
@ -1624,9 +1635,9 @@ PlumageRender::PlumageRender()
//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.setLookAtPoint(settings.cameraFixation);
//camera.setUp(glm::vec3(0.f,1.f,0.f));
camera.setUp(glm::vec3(0.f,1.f,1.f));
camera.setUp(glm::vec3(0.f,1.f,0.f));
camera.rotationSpeed = 0.25f;
camera.movementSpeed = 0.1f;