funcionalidade transformacao

Author: RochaCarla

include/data_format.h

@@ -0,0 +1,10 @@
+#ifndef DATA_FORMAT_H
+#define DATA_FORMAT_H
+
+namespace ijengine {
+	    typedef struct Matrix4f{
+			float m[4][4];
+		} matrix4f;
+}
+
+#endif

include/math3D.h

@@ -0,0 +1,14 @@
+#ifndef MATH3D_H
+#define MATH3D_H
+#include "data_format.h"
+
+namespace ijengine {
+
+    class Math3D {
+    public:
+        ~Math3D() = default;
+        matrix4f Mult(matrix4f Left, matrix4f Right);
+    };
+}
+
+#endif

include/sdlglgame.h

@@ -8,7 +8,7 @@
 #include "glrenderer3d.h"
 #include "window.h"
 #include "shader_manager.h"
-
+#include "transformation.h"
 
 #include <memory>
 

include/transformation.h

@@ -0,0 +1,32 @@
+#ifndef TRANSFORMATION_H
+#define TRANSFORMATION_H
+#include "math3D.h"
+
+namespace ijengine {
+
+    class Transformation {
+    public:
+    	Transformation();
+       	~Transformation();
+       	void setTranslation(float x, float y, float z);
+       	void setRotationX(float angle);
+       	void setRotationY(float angle);
+       	void setRotationZ(float angle);
+       	void setScale(float scale);
+       	void setPerspective(float near, float far, float angle, float width, float height);
+       	void setOrtogonal();
+       	matrix4f getTransformation();
+    private:
+       	void printMatrix(matrix4f matrix);
+    	matrix4f m_Trans;
+    	matrix4f m_RotX;
+    	matrix4f m_RotY;
+    	matrix4f m_RotZ;
+    	matrix4f m_Scale;
+    	matrix4f m_Perspective;
+    	void loadIdentity(matrix4f& Trans);
+
+    };
+}
+
+#endif

src/math3D.cpp

@@ -0,0 +1,20 @@
+#include "math3D.h"
+
+using namespace std;
+
+namespace ijengine{
+
+	matrix4f
+	Math3D::Mult(matrix4f Left, matrix4f Right){
+		matrix4f Ret;
+    	for (unsigned int i = 0 ; i < 4 ; i++) {
+       		for (unsigned int j = 0 ; j < 4 ; j++) {
+           		Ret.m[i][j] = Left.m[i][0] * Right.m[0][j] +
+                        	  Left.m[i][1] * Right.m[1][j] +
+                              Left.m[i][2] * Right.m[2][j] +
+                          	  Left.m[i][3] * Right.m[3][j];
+       		}
+    	}
+    	return Ret;
+	}
+}

src/sdlglgame.cpp

@@ -1,12 +1,14 @@
 #include "sdlglgame.h"
 
+
 using std::make_shared;
 
 namespace ijengine {
 
     SDLGLGame::SDLGLGame()
         : m_lib_sdl(new LibSDL2())
     {
+        
         if (m_lib_sdl)
             m_lib_sdl->init();
 
@@ -37,6 +39,15 @@ namespace ijengine {
             m_window->renderer3d()->notifyEndFrame();
              SDL_Delay(300);
         }
-    }
 
+        Transformation transformation;
+        
+        transformation.setTranslation(3.0, 3.0, 3.0);
+        transformation.setRotationX(45);
+        transformation.setRotationY(15);
+        transformation.setRotationZ(45);
+        transformation.setScale(2.0);
+        transformation.setPerspective(3.0, 2.0, 45, 3.0, 2.0);
+
+    }
 }

src/transformation.cpp

@@ -0,0 +1,91 @@
+#include "math3D.h"
+#include "transformation.h"
+#include <math.h>
+#include <iostream>
+
+using namespace std;
+
+namespace ijengine{
+	Transformation::Transformation(){
+		loadIdentity(m_Trans);
+		loadIdentity(m_Scale);
+		loadIdentity(m_RotX);
+		loadIdentity(m_RotY);
+		loadIdentity(m_RotZ);
+		loadIdentity(m_Perspective);
+	}
+	Transformation::~Transformation(){
+		
+	}
+	void
+	Transformation::loadIdentity(matrix4f& Trans){
+		Trans = {1, 0, 0, 0,
+				 0, 1, 0, 0,
+				 0, 0, 1, 0,
+				 0, 0, 0, 1}; 
+	}
+	void
+	Transformation::setTranslation(float x, float y, float z){
+		m_Trans.m[0][3] = x;
+		m_Trans.m[1][3] = y;
+		m_Trans.m[2][3] = z;
+		printMatrix(m_Trans);
+	}
+	void
+	Transformation::setRotationX(float angle){
+		m_RotX.m[1][1] = cos(angle);
+		m_RotX.m[2][1] = -sin(angle);
+		m_RotX.m[1][2] = sin(angle);
+		m_RotX.m[2][2] = cos(angle);
+		printMatrix(m_RotX);
+	}
+	void
+	Transformation::setRotationY(float angle){
+		m_RotY.m[0][0] = cos(angle);
+		m_RotY.m[0][2] = sin(angle);
+		m_RotY.m[2][0] = -sin(angle);
+		m_RotY.m[2][2] = cos(angle);
+		printMatrix(m_RotY);
+	}
+	void
+	Transformation::setRotationZ(float angle){
+		m_RotZ.m[0][0] = cos(angle);
+		m_RotZ.m[0][1] = sin(angle);
+		m_RotZ.m[1][0] = -sin(angle);
+		m_RotZ.m[1][1] = cos(angle);
+		printMatrix(m_RotZ);
+	}
+	void
+	Transformation::setScale(float scale){
+		m_Scale.m[0][0] = scale;
+		m_Scale.m[1][1] = scale;
+		m_Scale.m[2][2] = scale;
+		printMatrix(m_Scale);
+	}
+
+	void
+	Transformation::setPerspective(float near, float far, float angle, float width, float height){
+		m_Perspective.m[0][0] = 1/((width/height)*tan(angle/2));
+		m_Perspective.m[1][1] = 1/(tan(angle/2));
+		m_Perspective.m[2][2] = (-near-far)/(near-far);
+		m_Perspective.m[2][3] = (2*(near*far))/(near-far);
+		printMatrix(m_Perspective);
+	}
+
+	void
+	Transformation::printMatrix(matrix4f matrix){
+		for (int i = 0; i < 4; ++i) {
+			for (int j = 0; j < 4; ++j)
+				cout << matrix.m[i][j] << " ";
+			cout << endl;
+		}
+	}
+
+	matrix4f 
+	Transformation::getTransformation(){
+		matrix4f Trans;
+		// Trans = Mult(m_RotX, m_Scale);
+		//Mult(m_Trans ,Mult(m_RotZ ,Mult(m_RotY ,(Mult(m_RotX, m_Scale))));
+		return Trans;
+	}
+}