TheRetikGM/opengl-learning
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Nove repo opengl-learning

Browse Source
This commit is contained in:
TheRetikGM
2021-02-12 15:43:03 +01:00
commit 63e3c0bc8b
1046 changed files with 358397 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
lessons/4. Advanced OpenGL/7. Advanced GLSL/Makefile Normal file
View File

@@ -0,0 +1,37 @@
NAME := main
CXX=g++
DEBUG :=
CXX_FLAGS := $(DEBUG) -std=c++14
LIBS := -lGL -lGLU -lglfw3 -lX11 -lXxf86vm -lXrandr -pthread -lXi -ldl -lm
INCLUDE := ../../../include/
BIN := bin
SRC := src
INPUT = src/main.cpp ../../../glad.c
all: $(BIN)/$(NAME)
run:
cd $(BIN) && ./$(NAME)
$(BIN)/$(NAME): $(SRC)/main.o $(SRC)/glad.o $(SRC)/Shader.o $(SRC)/stb_image.o $(SRC)/Camera.o $(SRC)/Framebuffer.o
$(CXX) $(CXX_FLAGS) -I$(INCLUDE) $^ -o $@ $(LIBS)
.cpp.o:
$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
.c.o:
$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
$(SRC)/glad.o: ../../../glad.c
$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
$(SRC)/stb_image.o: ../../../stb_image.cpp
$(CXX) $(CXX_FLAGS) -I$(INCLUDE) -c $< -o $@
# dependencies
$(SRC)/main.o: $(SRC)/main.cpp
$(SRC)/Shader.o: $(SRC)/Shader.cpp
clean:
rm -rf $(SRC)/*.o
touch $(SRC)/*

83
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/Camera.cpp Normal file
View File

@@ -0,0 +1,83 @@
#include "Camera.h"
#include <glm/gtc/matrix_transform.hpp>
Camera::Camera(glm::vec3 position, glm::vec3 worldUp, glm::vec3 worldFront, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(2.5f), MouseSensitivity(0.1f), FOV(45.0f), Mode(CAM_FLOAT)
{
this->Position = position;
this->WorldUp = worldUp;
this->Yaw = yaw;
this->Pitch = pitch;
this->WorldFront = worldFront;
this->WorldRight = glm::normalize(glm::cross(this->WorldFront, this->WorldUp));
updateCameraVectors();
}
void Camera::updateCameraVectors()
{
glm::vec3 front;
front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
front.y = sin(glm::radians(Pitch));
front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
Front = glm::normalize(front);
Right = glm::normalize(glm::cross(Front, WorldUp));
Up = glm::normalize(glm::cross(Right, Front));
}
glm::mat4 Camera::getViewMatrix()
{
return glm::lookAt(Position, Position + Front, WorldUp);
}
void Camera::ProccessKeyboard(camera_movement direction, float deltaTime)
{
switch (direction)
{
case CAM_FORWARD:
Position += deltaTime * MovementSpeed * Front;
break;
case CAM_BACKWARD:
Position -= deltaTime * MovementSpeed * Front;
break;
case CAM_LEFT:
Position -= deltaTime * MovementSpeed * Right;
break;
case CAM_RIGHT:
Position += deltaTime * MovementSpeed * Right;
break;
case CAM_UP:
Position += deltaTime * MovementSpeed * WorldUp;
break;
case CAM_DOWN:
Position -= deltaTime * MovementSpeed * WorldUp;
break;
}
}
void Camera::ProccessMouse(float xoffset, float yoffset, bool constrainPitch)
{
xoffset *= MouseSensitivity;
yoffset *= MouseSensitivity;
Yaw = fmodf(Yaw + xoffset, 360.0f);
Pitch += yoffset;
if (constrainPitch)
{
if (Pitch > 89.0f)
Pitch = 89.0f;
else if (Pitch < -89.0f)
Pitch = -89.0f;
}
updateCameraVectors();
}
void Camera::ProccessScroll(float yoffset)
{
FOV -= yoffset;
if (FOV < 1.0f)
FOV = 1.0f;
else if (FOV > 45.0f)
FOV = 45.0f;
}
void Camera::SetCameraMode(camera_mode mode)
{
Mode = mode;
}

54
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/Camera.h Normal file
View File

@@ -0,0 +1,54 @@
#pragma once
#include <glm/glm.hpp>
enum camera_movement {
CAM_FORWARD,
CAM_BACKWARD,
CAM_LEFT,
CAM_RIGHT,
CAM_UP,
CAM_DOWN
};
enum camera_mode {
CAM_FLOAT,
CAM_MINECRAFT
};
class Camera
{
public:
float FOV;
float MovementSpeed;
float MouseSensitivity;
float Yaw; // vlevo vpravo
float Pitch; // nahoru dolu
camera_mode Mode;
glm::vec3 Position;
glm::vec3 Front;
glm::vec3 Right;
glm::vec3 Up;
glm::vec3 WorldUp;
glm::vec3 WorldRight;
glm::vec3 WorldFront;
Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3 worldUp = glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec3 worldFront = glm::vec3(0.0f, 0.0f, -1.0),
float yaw = -90.0f, float pitch = 0);
glm::mat4 getViewMatrix();
void ProccessKeyboard(camera_movement direction, float deltaTime);
void ProccessMouse(float xoffset, float yoffset, bool constrainPitch = true);
void ProccessScroll(float yoffset);
void SetCameraMode(camera_mode mode);
private:
float lastY;
float lastX;
void updateCameraVectors();
};

139
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/Framebuffer.cpp Normal file
View File

@@ -0,0 +1,139 @@
#include "Framebuffer.h"
#include <glad/glad.h>
#include <iostream>
#include <vector>
Framebuffer::Framebuffer(const int& width, const int& height)
{
glGenFramebuffers(1, &ID);
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glGenTextures(1, &ColorBuffer);
glBindTexture(GL_TEXTURE_2D, ColorBuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, ColorBuffer, 0);
glGenRenderbuffers(1, &DepthStencilBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, DepthStencilBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, DepthStencilBuffer);
if (checkStatus() != 0)
{
glDeleteRenderbuffers(1, &DepthStencilBuffer);
glDeleteTextures(1, &ColorBuffer);
glDeleteFramebuffers(1, &ID);
std::cerr << "FRAMEBUFFER::ERROR Could not create framebuffer object." << std::endl;
return;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
this->width = width;
this->height = height;
}
Framebuffer::~Framebuffer()
{
glDeleteRenderbuffers(1, &DepthStencilBuffer);
glDeleteTextures(1, &ColorBuffer);
glDeleteFramebuffers(1, &ID);
}
int Framebuffer::checkStatus()
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
switch (status)
{
case GL_FRAMEBUFFER_COMPLETE:
return 0;
break;
default:
fprintf(stderr, "Framebuffer.h: [ERROR] code: %#04x\n", (int)status);
return -1;
break;
}
}
/* updates width and height of buffers */
void Framebuffer::UpdateSize(const unsigned int& newWidth, const unsigned int& newHeight)
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glBindTexture(GL_TEXTURE_2D, ColorBuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, newWidth, newHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glDeleteRenderbuffers(1, &DepthStencilBuffer);
glGenRenderbuffers(1, &DepthStencilBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, DepthStencilBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, newWidth, newHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, DepthStencilBuffer);
}
/* sets opengl to use this framebuffer */
void Framebuffer::Use()
{
glBindFramebuffer(GL_FRAMEBUFFER, ID);
}
/* sets opengl to use default buffer */
void Framebuffer::UseDefault()
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void Framebuffer::clearBuffers(float r, float g, float b, float a)
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glClearColor(r, g, b, a);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
void Framebuffer::clearColorBuffer(float r, float g, float b, float a)
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glClearColor(r, g, b, a);
glClear(GL_COLOR_BUFFER_BIT);
}
void Framebuffer::clearDepthBuffer()
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glClear(GL_DEPTH_BUFFER_BIT);
}
void Framebuffer::clearStencilBuffer()
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glClear(GL_STENCIL_BUFFER_BIT);
}
void Framebuffer::clearDepthStencilBuffer()
{
if (!checkBind())
glBindFramebuffer(GL_FRAMEBUFFER, ID);
glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
unsigned int Framebuffer::getWidth()
{
return width;
}
unsigned int Framebuffer::getHeight()
{
return height;
}
bool Framebuffer::checkBind()
{
int id = 0;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &id);
if (id == ID)
return true;
return false;
}

36
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/Framebuffer.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
class Framebuffer
{
public:
/* opengl texture2D */
unsigned int ColorBuffer;
/* renderbuffer depth 24 bits stencil 8 bits */
unsigned int DepthStencilBuffer;
/* id of this framebuffer */
unsigned int ID;
Framebuffer(const int& width, const int& height);
~Framebuffer();
/* updates width and height of buffers */
void UpdateSize(const unsigned int& newWidth, const unsigned int& newHeight);
/* sets opengl to use this framebuffer */
void Use();
/* sets opengl to use default buffer */
void UseDefault();
void clearBuffers(float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f);
void clearColorBuffer(float r = 0.0f, float g = 0.0f, float b = 0.0f, float a = 1.0f);
void clearDepthBuffer();
void clearStencilBuffer();
void clearDepthStencilBuffer();
unsigned int getWidth();
unsigned int getHeight();
private:
unsigned int width;
unsigned int height;
int checkStatus();
bool checkBind();
};

119
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/Shader.cpp Normal file
View File

@@ -0,0 +1,119 @@
#include "Shader.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <glad/glad.h>
#include <glm/gtc/type_ptr.hpp>
Shader::Shader(const char* vertexShaderSourcePath, const char* fragmentShaderSourcePath, bool directSource)
{
const char* vertexSource;
const char* fragmentSource;
std::string v, f;
if (!directSource)
{
v = readFile(vertexShaderSourcePath);
f = readFile(fragmentShaderSourcePath);
vertexSource = v.c_str();
fragmentSource = f.c_str();
}
else
{
vertexSource = vertexShaderSourcePath;
fragmentSource = fragmentShaderSourcePath;
}
int success;
char infoLog[512];
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cerr << "Shader.h: [ERROR] Vertex shader compilation failed!\n" << infoLog << std::endl;
}
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cerr << "Shader.h: [ERROR] Fragment shader compilation failed!\n" << infoLog << std::endl;
}
Program = glCreateProgram();
glAttachShader(Program, vertexShader);
glAttachShader(Program, fragmentShader);
glLinkProgram(Program);
glGetProgramiv(Program, GL_LINK_STATUS, &success);
if (!success)
{
glGetProgramInfoLog(Program, 512, NULL, infoLog);
std::cerr << "[ERROR] Program linking failed\n" << infoLog << std::endl;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
}
Shader::Shader(std::string vertexShaderSourcePath, std::string fragmentShaderSourcePath, bool directSource)
{
Shader(vertexShaderSourcePath.c_str(), fragmentShaderSourcePath.c_str(), directSource);
}
Shader::~Shader()
{
glDeleteProgram(Program);
}
std::string Shader::readFile(const char* path)
{
std::string out;
try
{
std::ifstream ifs(path); // input file stream
std::stringstream buffer;
buffer << ifs.rdbuf();
out = buffer.str();
}
catch (std::ifstream::failure e)
{
std::cerr << "[ERROR] Could not read/open file '" << path << "'\n";
}
return out;
}
void Shader::Use()
{
glUseProgram(Program);
}
void Shader::setBool(const std::string name, bool value) const
{
glUniform1i(glGetUniformLocation(Program, name.c_str()), value ? 1 : 0);
}
void Shader::setFloat(const std::string name, float value) const
{
glUniform1f(glGetUniformLocation(Program, name.c_str()), value);
}
void Shader::setInt(const std::string name, int value) const
{
glUniform1i(glGetUniformLocation(Program, name.c_str()), value);
}
void Shader::setMat4(const std::string name, glm::mat4 value) const
{
glUniformMatrix4fv(glGetUniformLocation(Program, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
}
void Shader::setVec3(const std::string name, glm::vec3 value) const
{
setVec3(name, value.x, value.y, value.z);
}
void Shader::setVec3(const std::string name, float v0, float v1, float v2) const
{
glUniform3f(glGetUniformLocation(Program, name.c_str()), v0, v1, v2);
}
void Shader::setMat3(const std::string name, glm::mat3 value) const
{
glUniformMatrix3fv(glGetUniformLocation(Program, name.c_str()), 1, GL_FALSE, glm::value_ptr(value));
}

27
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/Shader.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include <string>
#include <glm/glm.hpp>
class Shader
{
public:
unsigned int Program;
Shader(const char* vertexShaderSourcePath, const char* fragmentShaderSourcePath, bool directSource = false);
Shader(std::string vertexShaderSourcePath, std::string fragmentShaderSourcePath, bool directSource = false);
~Shader();
void Use();
void setBool(const std::string name, bool value) const;
void setFloat(const std::string name, float value) const;
void setInt(const std::string name, int value) const;
void setMat4(const std::string name, glm::mat4 value) const;
void setVec3(const std::string name, glm::vec3 value) const;
void setVec3(const std::string name, float v0, float v1, float v2) const;
void setMat3(const std::string name, glm::mat3 value) const;
static std::string readFile(const char* path);
};

369
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/main.cpp Normal file
View File

@@ -0,0 +1,369 @@
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <stb_image.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <vector>
#include "Shader.h"
#include "Camera.h"
#include "Framebuffer.h"
#define WINDOW_NAME "7. Advanced GLSL"
#define TEXTURES_DIR "../../../../textures/"
#define MODELS_DIR "../../../../models/"
#define SHADERS_DIR "../src/shaders/"
using namespace std;
typedef unsigned int uint;
using std::vector;
using std::string;
// Global Constants
// ...
// Global Variables
GLFWwindow* window;
int WINDOW_WIDTH = 800;
int WINDOW_HEIGHT = 600;
Camera myCamera(glm::vec3(0.0f, 0.0f, 3.0f));
float deltaTime = 0.0f;
float lastFrame = 0.0f;
float lastX = 400;
float lastY = 300;
bool firstmouse = true;
glm::vec3 lightPos(1.2f, 1.0f, 2.0f);
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
uint8_t init(void);
void framebuffersize_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
void proccessInput(GLFWwindow* window);
unsigned int load_texture(const char* path, bool flip = true, GLint wrapS = GL_REPEAT, GLint wrapT = GL_REPEAT);
unsigned int load_cubemap(vector<string> faces);
int main(int argc, char** argv)
{
if (init() != 0)
return -1;
Shader shaderRed(SHADERS_DIR "shader.vert", SHADERS_DIR "shaderRed.frag");
Shader shaderGreen(SHADERS_DIR "shader.vert", SHADERS_DIR "shaderGreen.frag");
Shader shaderBlue(SHADERS_DIR "shader.vert", SHADERS_DIR "shaderBlue.frag");
Shader shaderYellow(SHADERS_DIR "shader.vert", SHADERS_DIR "shaderYellow.frag");
Shader quadShader(SHADERS_DIR "quadShader.vert", SHADERS_DIR "quadShader.frag");
Framebuffer framebuffer(WINDOW_WIDTH, WINDOW_HEIGHT);
// objects VAOs VBOs and vertices
float cubeVertices[] = {
// back face
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, // bottom-left
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, // bottom-right
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, // top-left
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, // bottom-left
// front face
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-left
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, // top-right
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, // bottom-right
0.5f, 0.5f, 0.5f, 1.0f, 1.0f, // top-right
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-left
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, // top-left
// left face
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-right
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-left
-0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-left
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-left
-0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-right
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-right
// right face
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-left
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right
0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-right
0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // bottom-right
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-left
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // top-left
// bottom face
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // top-right
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, // bottom-left
0.5f, -0.5f, -0.5f, 1.0f, 1.0f, // top-left
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, // bottom-left
-0.5f, -0.5f, -0.5f, 0.0f, 1.0f, // top-right
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, // bottom-right
// top face
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, // top-left
0.5f, 0.5f, -0.5f, 1.0f, 1.0f, // top-right
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // bottom-right
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, // bottom-right
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, // bottom-left
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f // top-left
};
float quadVertices[] = {
-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f
};
unsigned int cubeVAO, cubeVBO;
glGenVertexArrays(1, &cubeVAO);
glGenBuffers(1, &cubeVBO);
glBindVertexArray(cubeVAO);
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), cubeVertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (const void*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
unsigned int quadVAO, quadVBO;
glGenVertexArrays(1, &quadVAO);
glGenBuffers(1, &quadVBO);
glBindVertexArray(quadVAO);
glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_TRUE, 4 * sizeof(float), (const void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const void*)(2 * sizeof(float)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
unsigned int uniformBlockIndexRed = glGetUniformBlockIndex(shaderRed.Program, "Matrices");
unsigned int uniformBlockIndexGreen = glGetUniformBlockIndex(shaderGreen.Program, "Matrices");
unsigned int uniformBlockIndexBlue = glGetUniformBlockIndex(shaderBlue .Program, "Matrices");
unsigned int uniformBlockIndexYellow = glGetUniformBlockIndex(shaderYellow.Program, "Matrices");
// Bind uniform blocks to the binding point 0
glUniformBlockBinding(shaderRed.Program, uniformBlockIndexRed, 0);
glUniformBlockBinding(shaderGreen.Program, uniformBlockIndexGreen, 0);
glUniformBlockBinding(shaderBlue.Program, uniformBlockIndexBlue, 0);
glUniformBlockBinding(shaderYellow.Program, uniformBlockIndexYellow, 0);
unsigned int uboMatrices; // uniform buffer object that holds projection and view matrix
glGenBuffers(1, &uboMatrices);
glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
// size of glm::mat4 directly corresponds to the size of mat4 in GLSL. (64 bytes)
glBufferData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), NULL, GL_STATIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
// bind full buffer ubo matrices to binding point 0 ( same as in functions glUniformBlockBinding)
glBindBufferRange(GL_UNIFORM_BUFFER, 0, uboMatrices, 0, 2 * sizeof(glm::mat4));
quadShader.Use();
quadShader.setInt("quadTexture", 0);
/* ------------------ MAIN loop ------------------ */
while (!glfwWindowShouldClose(window)) {
float currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame; // cas jak dlouho trval posledni frame
lastFrame = currentFrame; // cas kdy zacal tento frame
// input ...
proccessInput(window);
// rendering commands here ...
framebuffer.Use();
framebuffer.clearBuffers();
glEnable(GL_DEPTH_TEST);
glm::mat4 model(1.0f);
glm::mat4 view = myCamera.getViewMatrix();
glm::mat4 projection(1.0f);
projection = glm::perspective(glm::radians(myCamera.FOV), (float)WINDOW_WIDTH / WINDOW_HEIGHT, 0.1f, 100.0f);
glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(projection));
glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), (float*)&view[0]);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glBindVertexArray(cubeVAO);
model = glm::translate(model, glm::vec3(-0.75f, 0.75f, 0.0f));
shaderRed.Use();
shaderRed.setMat4("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);
model = glm::translate(glm::mat4(1.0f), glm::vec3(0.75f, 0.75f, 0.0f));
shaderGreen.Use();
shaderGreen.setMat4("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);
model = glm::translate(glm::mat4(1.0f), glm::vec3(0.75f, -0.75f, 0.0f));
shaderBlue.Use();
shaderBlue.setMat4("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);
model = glm::translate(glm::mat4(1.0f), glm::vec3(-0.75f, -0.75f, 0.0f));
shaderYellow.Use();
shaderYellow.setMat4("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);
/* DRAW TO ACTUAL SCREEN */
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST); // disable depth test, so that the quad on the screen wont get replaced
quadShader.Use();
quadShader.setMat4("PVM", glm::mat4(1.0f));
glBindVertexArray(quadVAO);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, framebuffer.ColorBuffer);
glDrawArrays(GL_TRIANGLES, 0, 6);
// check and calls events and swap the buffers
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwTerminate();
return 0;
}
uint8_t init(void) {
// init of glfw window
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_NAME, NULL, NULL);
if (window == NULL) {
cerr << "Failed to create glfw window" << endl;
glfwTerminate();
return 1;
}
glfwMakeContextCurrent(window);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// init of GLAD
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
cerr << "Failed to initialize GLAD" << endl;
}
glfwSetFramebufferSizeCallback(window, framebuffersize_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
return 0;
}
void framebuffersize_callback(GLFWwindow* window, int width, int height)
{
glViewport(0, 0, width, height);
WINDOW_HEIGHT = height;
WINDOW_WIDTH = width;
}
void proccessInput(GLFWwindow* window)
{
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
if (glfwGetKey(window, GLFW_KEY_F1) == GLFW_PRESS)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
if (glfwGetKey(window, GLFW_KEY_F2) == GLFW_PRESS)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
/* -------------------- Movement -------------------- */
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
myCamera.ProccessKeyboard(CAM_FORWARD, deltaTime);
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
myCamera.ProccessKeyboard(CAM_BACKWARD, deltaTime);
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
myCamera.ProccessKeyboard(CAM_RIGHT, deltaTime);
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
myCamera.ProccessKeyboard(CAM_LEFT, deltaTime);
if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS)
myCamera.ProccessKeyboard(CAM_DOWN, deltaTime);
if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
myCamera.ProccessKeyboard(CAM_UP, deltaTime);
}
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
if (firstmouse) {
lastX = xpos;
lastY = ypos;
firstmouse = false;
}
float xoffset = xpos - lastX;
float yoffset = lastY - ypos;
lastX = xpos;
lastY = ypos;
myCamera.ProccessMouse(xoffset, yoffset);
}
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
{
myCamera.ProccessScroll(yoffset);
}
unsigned int load_texture(const char* path, bool flip, GLint wrapS, GLint wrapT)
{
unsigned int texture = 0;
int width, height, nrChannels, format;
stbi_set_flip_vertically_on_load(flip);
unsigned char* data = stbi_load(path, &width, &height, &nrChannels, 0); // load image to the array of bytes (char = 1 byte)
switch (nrChannels)
{
case 4: format = GL_RGBA; break;
case 3: format = GL_RGB; break;
case 2: format = GL_RED; break;
default: format = GL_RGB; break;
}
if (data) // data != NULL
{
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); // generates texture
glGenerateMipmap(GL_TEXTURE_2D);
}
else {
cerr << "Could not load texture '" << path << "'\n";
}
stbi_image_free(data);
glBindTexture(GL_TEXTURE_2D, 0);
return texture;
}
unsigned int load_cubemap(vector<string> faces)
{
unsigned int textureID;
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);
int width, height, nrChannels, format;
for (int i = 0; i < faces.size(); i++)
{
unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0);
switch (nrChannels)
{
case 4: format = GL_RGBA; break;
case 3: format = GL_RGB; break;
case 2: format = GL_RED; break;
default: format = GL_RGB; break;
}
if (data)
{
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
}
else {
std::cerr << "[ERROR] Failed to load cubemap texture at " << faces[i] << std::endl;
}
stbi_image_free(data);
};
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
return textureID;
}

41
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/quadShader.frag Normal file
View File

@@ -0,0 +1,41 @@
#version 330 core
out vec4 FragColor;
in vec2 TexCoord;
uniform sampler2D quadTexture;
float offset = 1.0 / 300.0;
void main()
{
// Grayscale
// FragColor = texture(quadTexture, TexCoord);
// float avarage = 0.2126 * FragColor.r + 0.7152 * FragColor.g + 0.0722 * FragColor.b;
// FragColor = vec4(avarage, avarage, avarage, 1.0);
vec2 offsets[9] = vec2[](
vec2(-offset, offset), // top-left
vec2(0.0, offset), // top-center
vec2(offset, offset), // top-right
vec2(-offset, 0.0), // center-right
vec2(0.0, 0.0), // center-center
vec2(offset, 0.0), // center-right
vec2(-offset, -offset), // bottom-left
vec2(0.0, -offset), // bottom-center
vec2(offset, -offset) // bottom-right
);
float kernel[9] = float[](
0, 0, 0,
0, 1, 0,
0, 0, 0
);
vec3 col = vec3(0.0);
for (int i = 0; i < 9; i++)
{
col += vec3(texture(quadTexture, TexCoord.st + offsets[i])) * kernel[i];
}
FragColor = vec4(col, 1.0);
}

14
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/quadShader.vert Normal file
View File

@@ -0,0 +1,14 @@
#version 330 core
layout (location = 0) in vec2 aPos;
layout (location = 1) in vec2 aTexCoord;
out vec2 TexCoord;
uniform mat4 PVM;
void main()
{
gl_Position = PVM * vec4(aPos.x, aPos.y, 0.0, 1.0);
TexCoord = aTexCoord;
}

15
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/shader.vert Normal file
View File

@@ -0,0 +1,15 @@
#version 330
layout (location = 0) in vec3 aPosition;
layout (std140) uniform Matrices
{
mat4 projection;
mat4 view;
};
uniform mat4 model;
void main()
{
gl_Position = projection * view * model * vec4(aPosition, 1.0);
}

12
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/shaderBlue.frag Normal file
View File

@@ -0,0 +1,12 @@
#version 330
out vec4 FragColor;
void main()
{
if (!gl_FrontFacing)
FragColor = vec4(0.0, 0.0, 1.0, 1.0);
else
FragColor = vec4(1.0, 1.0, 0.0, 1.0);
}

11
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/shaderGreen.frag Normal file
View File

@@ -0,0 +1,11 @@
#version 330
out vec4 FragColor;
void main()
{
if (!gl_FrontFacing)
FragColor = vec4(0.0, 1.0, 0.0, 1.0);
else
FragColor = vec4(1.0, 0.0, 1.0, 1.0);
}

11
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/shaderRed.frag Normal file
View File

@@ -0,0 +1,11 @@
#version 330
out vec4 FragColor;
void main()
{
if (!gl_FrontFacing)
FragColor = vec4(1.0, 0.0, 0.0, 1.0);
else
FragColor = vec4(0.0, 1.0, 1.0, 1.0);
}

11
lessons/4. Advanced OpenGL/7. Advanced GLSL/src/shaders/shaderYellow.frag Normal file
View File

@@ -0,0 +1,11 @@
#version 330
out vec4 FragColor;
void main()
{
if (!gl_FrontFacing)
FragColor = vec4(1.0, 1.0, 0.0, 1.0);
else
FragColor = vec4(0.0, 0.0, 1.0, 1.0);
}