Merge branch 'salmon' of github.com:mephi1984/ZeptoLabTest1 into pavel

Environment.cpp

@@ -10,7 +10,7 @@ namespace ZL {
 int Environment::windowHeaderHeight = 0;
 int Environment::width = 0;
 int Environment::height = 0;
-float Environment::zoom = 10.0f;
+float Environment::zoom = 3.f;
 
 bool Environment::leftPressed = false;
 bool Environment::rightPressed = false;

Game.cpp

@@ -53,6 +53,7 @@ void Game::setup() {
     // Initialize renderer
     renderer.shaderManager.AddShaderFromFiles("default", "./default.vertex", "./default.fragment");
     renderer.shaderManager.AddShaderFromFiles("defaultColor", "./defaultColor.vertex", "./defaultColor.fragment");
+    renderer.shaderManager.AddShaderFromFiles("defaultHideCam", "./defaultHideCam.vertex", "./defaultHideCam.fragment");
 
     // Initialize game objects
     std::cout << "Hello 2" << std::endl;

GameObjectManager.cpp

@@ -182,6 +182,10 @@ void GameObjectManager::handleEvent(const SDL_Event& event) {
         if (Environment::zoom < zoomstep) {
             Environment::zoom = zoomstep;
         }
+        if (Environment::zoom > 4)
+        {
+            Environment::zoom = 4;
+        }
     }
     else if (event.type == SDL_KEYDOWN) {
         switch (event.key.keysym.sym) {
@@ -391,6 +395,18 @@ void GameObjectManager::updateScene(size_t ms) {
         Environment::cameraShift.v[0] += directionVector.v[0] * ms;
         Environment::cameraShift.v[2] += directionVector.v[1] * ms;
     }
+    if (Environment::downPressed) {
+        Environment::cameraShift.v[0] -= directionVector.v[0] * ms;
+        Environment::cameraShift.v[2] -= directionVector.v[1] * ms;
+    }
+    if (Environment::rightPressed) {
+        Environment::cameraShift.v[2] += directionVector.v[0] * ms;
+        Environment::cameraShift.v[0] -= directionVector.v[1] * ms;
+    }
+    if (Environment::leftPressed) {
+        Environment::cameraShift.v[2] -= directionVector.v[0] * ms;
+        Environment::cameraShift.v[0] += directionVector.v[1] * ms;
+    }
 
     Environment::characterPos.v[0] = -Environment::cameraShift.v[0];
     Environment::characterPos.v[1] = -Environment::cameraShift.v[1];

RenderSystem.cpp

@@ -9,9 +9,11 @@
 namespace ZL {
 
 void RenderSystem::initialize() {
+    /*
     renderer.shaderManager.AddShaderFromFiles("default", "./default.vertex", "./default.fragment");
+    renderer.shaderManager.AddShaderFromFiles("defaultHideCam", "./defaultHideCam.vertex", "./defaultHideCam.fragment");
     renderer.shaderManager.AddShaderFromFiles("defaultColor", "./defaultColor.vertex", "./defaultColor.fragment");
-    renderer.InitOpenGL();
+    renderer.InitOpenGL();*/
 }
 
 void RenderSystem::drawScene(GameObjectManager& gameObjects) {
@@ -100,12 +102,15 @@ void RenderSystem::drawViola(GameObjectManager& gameObjects)
 void RenderSystem::drawWorld(GameObjectManager& gameObjects) {
     static const std::string defaultShaderName = "default";
     static const std::string colorShaderName = "defaultColor";
+    static const std::string hideCamShaderName = "defaultHideCam";
 
     static const std::string vPositionName = "vPosition";
     static const std::string vTexCoordName = "vTexCoord";
     static const std::string vColorName = "vColor";
     static const std::string textureUniformName = "Texture";
 
+    //static const std::string modelViewMatrixName = "modelView";
+
     /*
     renderer.shaderManager.PushShader(defaultShaderName);
     renderer.RenderUniform1i(textureUniformName, 0);
@@ -122,9 +127,24 @@ void RenderSystem::drawWorld(GameObjectManager& gameObjects) {
 
     drawViola(gameObjects);
 
-    renderer.shaderManager.PushShader(defaultShaderName);
+    renderer.shaderManager.PushShader(hideCamShaderName);
     renderer.RenderUniform1i(textureUniformName, 0);
 
+    Vector3f totalCameraTargetPos = Environment::characterPos - Vector3f{ 0, Environment::cameraDefaultVerticalShift, 0 };
+
+    renderer.RenderUniform3fv("targetPos", &totalCameraTargetPos.v[0]);
+
+    Vector3f cameraPos = Vector3f{ 0,0, 100 * Environment::zoom };
+
+    cameraPos = MultVectorMatrix(cameraPos, QuatToMatrix(QuatFromRotateAroundX(Environment::cameraAlpha)));
+    cameraPos = MultVectorMatrix(cameraPos, QuatToMatrix(QuatFromRotateAroundY(Environment::cameraPhi)));
+
+    cameraPos = cameraPos + totalCameraTargetPos;
+    renderer.RenderUniform3fv("eyePos", &cameraPos.v[0]);
+    //renderer.RenderUniform3fv("eyePos", &testVec2.v[0]);
+
+
+
     renderer.EnableVertexAttribArray(vPositionName);
     renderer.EnableVertexAttribArray(vTexCoordName);
 

Renderer.cpp

@@ -590,6 +590,18 @@ namespace ZL {
 		}
 	}
 
+	void Renderer::RenderUniform3fv(const std::string& uniformName, const float* value)
+	{
+		auto shader = shaderManager.GetCurrentShader();
+
+		auto uniform = shader->uniformList.find(uniformName);
+
+		if (uniform != shader->uniformList.end())
+		{
+			glUniform3fv(uniform->second, 1, value);
+		}
+	}
+
 	void Renderer::RenderUniform1i(const std::string& uniformName, const int value)
 	{
 		auto shader = shaderManager.GetCurrentShader();

Renderer.h

@@ -118,6 +118,8 @@ namespace ZL {
 
 		void RenderUniformMatrix4fv(const std::string& uniformName, bool transpose, const float* value);
 		void RenderUniform1i(const std::string& uniformName, const int value);
+		void RenderUniform3fv(const std::string& uniformName, const float* value);
+
 
 		void VertexAttribPointer2fv(const std::string& attribName, int stride, const char* pointer);
 

defaultHideCam.fragment

@@ -0,0 +1,61 @@
+uniform sampler2D Texture;
+varying vec2 texCoord;
+varying vec3 vWorldPos;
+
+uniform vec3 eyePos;    // Позиция камеры
+uniform vec3 targetPos; // Цель камеры
+
+void main() 
+{
+/*
+	float maxDistance = 2000;
+	float alpha = 0.0;
+    vec4 color = texture2D(Texture, texCoord);
+    
+    vec3 dir = targetPos - eyePos;
+    float dirLengthSq = dot(dir, dir);
+    
+    if (dirLengthSq > 0.0) 
+    {
+        vec3 objToEye = vWorldPos - eyePos;
+        float t = dot(objToEye, dir) / dirLengthSq;
+        
+        if (t >= 0.0 && t <= 1.0) 
+        {
+            vec3 projection = eyePos + t * dir;
+            vec3 delta = vWorldPos - projection;
+            float distSq = dot(delta, delta);
+            
+            if (distSq < maxDistance * maxDistance) 
+            {
+                //color.a *= alpha; // Применяем прозрачность
+				color.rgb = vec3(1,0,0);
+            }
+        }
+    }
+    */
+	vec4 color;
+	
+	vec3 dirToCamera = normalize(eyePos - targetPos);
+    vec3 dirToVertex = normalize(vWorldPos - targetPos);
+	
+	float dotProduct = dot(dirToCamera, dirToVertex);
+	
+	float distanceX = abs(vWorldPos.x);
+	float distanceZ = abs(vWorldPos.z);
+	
+	//float distanceToCamera = length(vWorldPos - targetPos);
+	
+	if (/*(distanceX > 250 || distanceZ > 250) && */(dotProduct > 0.1) && vWorldPos.y > 30)
+	{
+		//color.rgba = vec4(1,0,0,1);
+		discard;
+    }
+	else
+	{
+		color.rgb = texture2D(Texture, texCoord).rgb;
+		//color.rgb = vec3(clamp(vWorldPos.z/500, 0, 1), 0, 0);
+		color.a = 1;
+	}
+	gl_FragColor = color;
+}

defaultHideCam.vertex

@@ -0,0 +1,15 @@
+attribute vec3 vPosition;
+attribute vec2 vTexCoord;
+varying vec2 texCoord;
+varying vec3 vWorldPos; // Мировая позиция вершины
+
+uniform mat4 ProjectionModelViewMatrix;
+//uniform mat4 ModelMatrix; // Матрица модели объекта
+
+void main() 
+{
+    vec4 worldPos = vec4(vPosition, 1.0);
+    vWorldPos = worldPos.xyz;
+    gl_Position = ProjectionModelViewMatrix * vec4(vPosition, 1.0);
+    texCoord = vTexCoord;
+}