diff --git a/base/camera.hpp b/base/camera.hpp
index e65308c..bcd8b35 100644
--- a/base/camera.hpp
+++ b/base/camera.hpp
@@ -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
 	*/
diff --git a/base/renderConfig.cpp b/base/renderConfig.cpp
index c815f7c..4b512f2 100644
--- a/base/renderConfig.cpp
+++ b/base/renderConfig.cpp
@@ -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;
diff --git a/base/renderConfig.h b/base/renderConfig.h
index 7648ae6..22029ee 100644
--- a/base/renderConfig.h
+++ b/base/renderConfig.h
@@ -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);
 
 
diff --git a/base/vulkanexamplebase.cpp b/base/vulkanexamplebase.cpp
index 6220826..94355b1 100644
--- a/base/vulkanexamplebase.cpp
+++ b/base/vulkanexamplebase.cpp
@@ -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();
diff --git a/src/render/render.cpp b/src/render/render.cpp
index 759ebfe..e716d8e 100644
--- a/src/render/render.cpp
+++ b/src/render/render.cpp
@@ -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;