fix projectionMatrix

base/camera.hpp

@@ -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;
 		
 	}

base/renderConfig.cpp

@@ -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]),
 											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;
+	glm::vec3 cameraTracksVecA = settings.cameraTracks[cameraTracksAndAngleSize / 4]  - settings.cameraTracks[0];
-	settings.fX = settings.fX * ratioX;
+	glm::vec3 cameraTracksVecB = settings.cameraTracks[cameraTracksAndAngleSize / 2] - settings.cameraTracks[0] ;
-	settings.fY = settings.fY * ratioY;
+	
-	settings.cX = settings.cX * ratioX;
+	glm::vec3 cameraTracksCircleNormal = glm::cross(cameraTracksVecA, cameraTracksVecB);
-	settings.cY = settings.cY * ratioY;
+	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()

base/renderConfig.h

@@ -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();
 

base/vulkanexamplebase.cpp

@@ -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)

src/render/render.cpp

@@ -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 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 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 = 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::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]);
 
 		
-		glm::vec3 translate = settings.cameraFixation - modelCenter;
+		//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);
+		//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::vec4 topNormal = glm::vec4(0,1,0,0);
+		//glm::vec3 bottomVec1 = glm::vec3(models.scene.aabb[0][0])
-		glm::vec4 modelTopNormal4 = glm::transpose(glm::inverse(shaderDataScene.model)) * topNormal;
+		//glm::mat4 rotationMatrix = glm::mat4(1.0f);
-		glm::vec3 modelTopNormal3 = glm::vec3(modelTopNormal4[0], modelTopNormal4[1], modelTopNormal4[2]);
+		//glm::vec4 topNormal4 = glm::vec4(topNormal, 0.0f);
-		glm::vec3 rotationAxis = glm::normalize(glm::cross(settings.bottomNormal, modelTopNormal3));
+		//glm::vec4 topNormal = glm::vec4(0,0,1,0);
-		float cosTheta = glm::dot(settings.bottomNormal, modelTopNormal3);
+		
-		float angle = acos(cosTheta);
+		
-		shaderDataScene.model = glm::rotate(glm::mat4(1.0f), angle, rotationAxis);
+
 		/*
 		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.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.calibrationWidth,settings.calibrationHeight,false,true);
+		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, 1.0f, 256.0f);
+		//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)
 	{

src/render/render.h

@@ -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();