Hello Triangle

5 files changed, 380 insertions, 0 deletions

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..6011de2
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,27 @@
+###########################
+
+#linux
+CMAKE=cmake
+
+#win
+CMAKE=/mnt/d/PROG/Microsoft\ Visual\ Studio/2022/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe
+
+.PHONY: run-debug run-release clean
+
+run-release: build-release
+	cd ./lib && ../build/Release/Tutorial.exe
+
+build-release: build
+	${CMAKE} --build ./build --config Release
+
+run-debug: build-debug
+	cd ./lib && ../build/Debug/Tutorial.exe
+
+build-debug: build
+	${CMAKE} --build ./build 
+
+build:
+	${CMAKE} -S ./src -B ./build
+
+clean:
+	rm build -rf
diff --git a/doc/README b/doc/README
new file mode 100644
index 0000000..ef07ae3
--- /dev/null
+++ b/doc/README
@@ -0,0 +1,9 @@
+More or less following: https://learnopengl.com/
+
+Build with cmake
+
+Dependencies:
+* freeglut
+* glew
+
+May 2022
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 0000000..468c2c4
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.10)

+project(Tutorial VERSION 1.0)

+

+include_directories("c:/Users/miguel/Downloads/freeglut-3.2.2.tar/freeglut-3.2.2/include")

+link_directories("c:/Users/miguel/Downloads/freeglut-3.2.2.tar/build/lib/Release")

+link_directories("c:/Users/miguel/Downloads/freeglut-3.2.2.tar/build/lib/Debug")

+

+include_directories("c:/Users/miguel/Downloads/glew-2.1.0-win32/glew-2.1.0/include")

+link_directories("c:/Users/miguel/Downloads/glew-2.1.0-win32/glew-2.1.0/lib/Release/x64")

+

+find_package(OpenGL REQUIRED)

+

+configure_file(TutorialConfig.h.in TutorialConfig.h)

+

+add_executable(Tutorial tutorial.cpp)

+

+target_link_libraries(Tutorial glew32)

+target_include_directories(Tutorial PUBLIC "${PROJECT_BINARY_DIR}")

diff --git a/src/TutorialConfig.h.in b/src/TutorialConfig.h.in
new file mode 100644
index 0000000..88ba639
--- /dev/null
+++ b/src/TutorialConfig.h.in
@@ -0,0 +1,3 @@
+// the configured options and settings for Tutorial
+ #define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
+ #define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
diff --git a/src/tutorial.cpp b/src/tutorial.cpp
new file mode 100644
index 0000000..e3f7a9d
--- /dev/null
+++ b/src/tutorial.cpp
@@ -0,0 +1,323 @@
+// https://learnopengl.com/Getting-started/OpenGL

+

+#include <iostream>

+

+#include <GL/glew.h>

+#include <GL/glut.h>

+

+#include "TutorialConfig.h"

+

+

+float x=-0.5;

+GLuint shaderProgram_glob;

+GLuint shaderProgram1_glob;

+GLuint VAO_glob;

+GLuint VAO1_glob;

+

+void renderScene(void) {

+

+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

+

+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

+

+        glUseProgram(shaderProgram1_glob);

+        glBindVertexArray(VAO1_glob);

+	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

+

+        glUseProgram(shaderProgram_glob);

+        glBindVertexArray(VAO_glob);

+        glDrawArrays(GL_TRIANGLES, 0, 3);

+

+

+	/* glBegin(GL_TRIANGLES) */

+	/* 	glVertex3f(-0.5,x,0.0); */

+	/* 	glVertex3f(0.5,0.0,0.0); */

+	/* 	glVertex3f(0.0,0.5,0.0); */

+	/* glEnd(); */

+

+        x+=0.1f;

+        if(x>0)x=-0.5;

+

+//	glutWarpPointer(100,100);

+        glutSwapBuffers();

+}

+

+void idle(void) {

+    glutPostRedisplay();

+}

+

+void processNormalKeysUp(unsigned char key, int x, int y) {

+        std::cout << "up" << std::endl;

+        if (key == 27) exit(0);

+}

+void processNormalKeysDown(unsigned char key, int x, int y) {

+        std::cout << "down" << std::endl;

+        if (key == 27) exit(0);

+}

+void processSpecKeysUp(int key, int x, int y) {

+        std::cout << "spec up" << std::endl;

+}

+void processSpecKeysDown(int key, int x, int y) {

+        std::cout << "spec down" << std::endl;

+}

+

+void exiting(){

+        std::cout << "game over" << std::endl;

+}

+

+void reshape(int w, int h){

+        std::cout << "reshape" << std::endl;

+	glViewport (0,0,w,h);

+}

+

+void tim (int v)

+{

+        std::cout << "tim" << std::endl;

+}

+int main(int argc, char **argv) {

+

+	atexit(exiting);

+

+	// init GLUT and create Window

+	glutInit(&argc, argv);

+	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

+	glutInitWindowPosition(100,100);

+	glutInitWindowSize(320,320);

+	glutCreateWindow("Lighthouse3D - GLUT Tutorial");

+	glutIdleFunc(idle);

+	glutDisplayFunc(renderScene);

+

+	glutReshapeFunc(reshape);

+

+	glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF);

+	glutKeyboardFunc(processNormalKeysDown);

+        glutKeyboardUpFunc(processNormalKeysUp);

+

+	glutSpecialFunc(processSpecKeysDown);

+	glutSpecialUpFunc(processSpecKeysUp);

+

+	glutSetCursor(GLUT_CURSOR_NONE);

+	//glutMouseFunc()

+	//glutMotionFunc()

+	//glutPassiveMotionFunc()

+

+	//glutEntryFunc();

+	//glutVisibilityFunc();

+

+        glutTimerFunc(3000,tim,1);

+        glutTimerFunc(6000,tim,1);

+

+

+

+        // call here - not to soon not too late :P 

+        GLenum err = glewInit();

+        if (err != GLEW_OK){

+            std::cout << "glew not ok" << std::endl;

+              exit(1); // or handle the error in a nicer way

+        }

+        if (!GLEW_VERSION_2_1){

+                     // check that the machine supports the 2.1 API.

+            std::cout << "glew version does not support 2.1" << std::endl;

+              exit(1); // or handle the error in a nicer way

+        }

+

+        int  success;

+        char infoLog[512];

+

+        const char *vertexShaderSource = "#version 330 core\n"

+                "layout (location = 0) in vec3 aPos;\n"

+                    "void main()\n"

+                        "{\n"

+                            "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"

+                                "}\0";

+        const char *fragmentShaderSource = "#version 330 core\n"

+            "out vec4 FragColor;  void main()   {           FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);      } \0";

+

+        const char *fragmentShader1Source = "#version 330 core\n"

+            "out vec4 FragColor;  void main()   {           FragColor = vec4(1.0f, 0.0f, 0.0f, 1.0f);      } \0";

+

+        GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);

+        glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);

+        glCompileShader(vertexShader);

+

+        glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

+        if(!success)

+        {

+                glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);

+                    std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;

+        }

+

+        GLuint fragmentShader;

+        fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

+        glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);

+        glCompileShader(fragmentShader);

+

+        glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);

+        if(!success)

+        {

+                glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);

+                    std::cout << "ERROR::SHADER::FRAG::COMPILATION_FAILED\n" << infoLog << std::endl;

+        }

+

+        GLuint fragmentShader1;

+        fragmentShader1 = glCreateShader(GL_FRAGMENT_SHADER);

+        glShaderSource(fragmentShader1, 1, &fragmentShader1Source, NULL);

+        glCompileShader(fragmentShader1);

+

+        glGetShaderiv(fragmentShader1, GL_COMPILE_STATUS, &success);

+        if(!success)

+        {

+                glGetShaderInfoLog(fragmentShader1, 512, NULL, infoLog);

+                    std::cout << "ERROR::SHADER::FRAG::COMPILATION_FAILED\n" << infoLog << std::endl;

+        }

+

+

+

+        GLuint shaderProgram = glCreateProgram();

+        shaderProgram_glob = shaderProgram;

+        glAttachShader(shaderProgram, vertexShader);

+        glAttachShader(shaderProgram, fragmentShader);

+        glLinkProgram(shaderProgram);

+

+        glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);

+        if(!success) {

+                glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);

+                    std::cout << "ERROR::SHADER::PROG::LINKING_FAILED\n" << infoLog << std::endl;

+        }

+

+        GLuint shaderProgram1 = glCreateProgram();

+        shaderProgram1_glob = shaderProgram1;

+        glAttachShader(shaderProgram1, vertexShader);

+        glAttachShader(shaderProgram1, fragmentShader1);

+        glLinkProgram(shaderProgram1);

+

+        glGetProgramiv(shaderProgram1, GL_LINK_STATUS, &success);

+        if(!success) {

+                glGetProgramInfoLog(shaderProgram1, 512, NULL, infoLog);

+                    std::cout << "ERROR::SHADER::PROG::LINKING_FAILED\n" << infoLog << std::endl;

+        }

+

+        glDeleteShader(vertexShader);

+        glDeleteShader(fragmentShader);  

+        glDeleteShader(fragmentShader1);  

+

+        float vertices[] = {

+            -0.5f, -0.5f, 0.0f,

+            0.5f, -0.5f, 0.0f,

+            0.0f,  0.5f, 0.0f

+        };

+

+        GLuint VBO;

+        glGenBuffers(1,&VBO);

+        glBindBuffer(GL_ARRAY_BUFFER, VBO);  

+        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

+

+        GLuint VAO;

+        glGenVertexArrays(1, &VAO);  

+        VAO_glob=VAO;

+        glBindVertexArray(VAO);

+        glBindBuffer(GL_ARRAY_BUFFER, VBO);

+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

+        glEnableVertexAttribArray(0);  

+

+	float vertices1[] = {

+	    0.5f,  0.5f, 0.0f,  // top right

+	    0.5f, -0.5f, 0.0f,  // bottom right

+	    -0.5f, -0.5f, 0.0f,  // bottom left

+	    -0.5f,  0.5f, 0.0f   // top left 

+	};

+

+        GLuint VBO1;

+        glGenBuffers(1,&VBO1);

+        glBindBuffer(GL_ARRAY_BUFFER, VBO1);  

+        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices1), vertices1, GL_STATIC_DRAW);

+

+        GLuint VAO1;

+        glGenVertexArrays(1, &VAO1);  

+        VAO1_glob=VAO1;

+        glBindVertexArray(VAO1);

+        glBindBuffer(GL_ARRAY_BUFFER, VBO1);

+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

+        glEnableVertexAttribArray(0);  

+

+	unsigned int indices1[] = {  // note that we start from 0!

+	    0, 1, 3,   // first triangle

+	    1, 2, 3    // second triangle

+	};  

+

+	GLuint EBO;

+	glGenBuffers(1, &EBO);

+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices1), indices1, GL_STATIC_DRAW); 

+

+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

+

+

+

+

+        //

+

+        std::cout << glGetString(GL_VERSION) << std::endl;

+

+	// register callbacks

+

+	// enter GLUT event processing cycle

+	glutMainLoop();

+	

+	return 1;

+}

+

+

+/* void setShaders() { */

+ 

+/*     GLuint v, g, f; */

+/*     char *vs,*gs, *fs; */

+ 

+/*     // Create shader handlers */

+/*     v = glCreateShader(GL_VERTEX_SHADER); */

+/*     g = glCreateShader(GL_GEOMETRY_SHADER); */

+/*     f = glCreateShader(GL_FRAGMENT_SHADER); */ 

+ 

+/*     // Read source code from files */

+/*     vs = textFileRead("example.vert"); */

+/*     gs = textFileRead("example.geom"); */

+/*     fs = textFileRead("example.frag"); */

+ 

+/*     const char * vv = vs; */

+/*     const char * gg = gs; */

+/*     const char * ff = fs; */

+ 

+/*     // Set shader source */

+/*     glShaderSource(v, 1, &vv,NULL); */

+/*     glShaderSource(g, 1, &gg,NULL); */

+/*     glShaderSource(f, 1, &ff,NULL); */

+ 

+/*     free(vs);free(gs);free(fs); */

+ 

+/*     // Compile all shaders */

+/*     glCompileShader(v); */

+/*     glCompileShader(g); */

+/*     glCompileShader(f); */

+ 

+/*     // Create the program */

+/*     p = glCreateProgram(); */

+ 

+/*     // Attach shaders to program */

+/*     glAttachShader(p,v); */

+/*     glAttachShader(p,g); */

+/*     glAttachShader(p,f); */

+ 

+/*     // Link and set program to use */

+/*     glLinkProgram(p); */

+/*     glUseProgram(p); */

+/* } */

+

+/* void main(int argc, char **argv) { */

+

+/*     glutInit(&argc, argv); */

+/*     setShaders(); */

+/*     initGL(); */

+/*     glutMainLoop(); */

+

+/* } */