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/3. Model loading/1. Mesh/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 -lassimp
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)/Model.o $(SRC)/Mesh.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/3. Model loading/1. Mesh/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/3. Model loading/1. Mesh/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();
};

67
lessons/3. Model loading/1. Mesh/src/Mesh.cpp Normal file
View File

@@ -0,0 +1,67 @@
#include <glad/glad.h>
#include "Mesh.h"
using namespace glml;
Mesh::Mesh(const std::vector<Vertex>& vertices,
const std::vector<unsigned int>& indices,
const std::vector<Texture>& textures) : vertices(vertices), indices(indices), textures(textures)
{
setupMesh();
}
void Mesh::setupMesh()
{
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Position));
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Normal));
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, TexCoord));
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Tangent));
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const void*)offsetof(Vertex, Bitangent));
for (int i = 0; i < 5; i++)
glEnableVertexAttribArray(i);
glBindVertexArray(0);
}
void Mesh::Draw(Shader& shader) const
{
unsigned int diffNr = 0;
unsigned int specNr = 0;
unsigned int normNr = 0;
unsigned int heigNr = 0;
for (int i = 0; i < textures.size(); i++)
{
std::string name = TextureTypeStrings[static_cast<size_t>(textures[i].type)];
if (textures[i].type == TextureType::diffuse)
name += std::to_string(diffNr++);
else if (textures[i].type == TextureType::specular)
name += std::to_string(specNr++);
else if (textures[i].type == TextureType::normal)
name += std::to_string(normNr++);
else if (textures[i].type == TextureType::height)
name += std::to_string(heigNr++);
glActiveTexture(GL_TEXTURE0 + i);
shader.setInt("material." + name, i);
glBindTexture(GL_TEXTURE_2D, textures[i].id);
}
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}

52
lessons/3. Model loading/1. Mesh/src/Mesh.h Normal file
View File

@@ -0,0 +1,52 @@
#pragma once
#include <glm/glm.hpp>
#include <string>
#include <vector>
#include "Shader.h"
namespace glml
{
static const std::string TextureTypeStrings[] = {
"texture_diffuse",
"texture_specular",
"texture_normal",
"texture_height"
};
enum class TextureType : size_t
{
diffuse = 0,
specular = 1,
normal = 2,
height = 3
};
struct Vertex {
glm::vec3 Position;
glm::vec3 Normal;
glm::vec2 TexCoord;
glm::vec3 Color;
glm::vec3 Tangent;
glm::vec3 Bitangent;
};
struct Texture {
unsigned int id;
TextureType type;
std::string path;
};
class Mesh {
public:
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::vector<Texture> textures;
Mesh(const std::vector<Vertex>& vertices, const std::vector<unsigned int>& indices, const std::vector<Texture>& textures);
void Draw(Shader& shader) const;
private:
unsigned int VAO, VBO, EBO;
void setupMesh();
};
};

187
lessons/3. Model loading/1. Mesh/src/Model.cpp Normal file
View File

@@ -0,0 +1,187 @@
#include <glad/glad.h>
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <iostream>
#include <stb_image.h>
#include "Model.h"
using namespace glml;
Model::Model(const std::string path)
{
loadModel(path);
}
void Model::Draw(Shader& shader) const
{
for (int i = 0; i < meshes.size(); i++)
meshes[i].Draw(shader);
}
void Model::loadModel(const std::string path)
{
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);
if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
{
std::cerr << "[ASSIMP ERROR] Model '" << path << "' not loaded.\n" << importer.GetErrorString() << std::endl;
return;
}
directory = path.substr(0, path.find_last_of('/'));
processNode(scene->mRootNode, scene);
}
void Model::processNode(aiNode* node, const aiScene* scene)
{
unsigned int i;
for (i = 0; i < node->mNumMeshes; i++)
{
aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
meshes.push_back(processMesh(mesh, scene));
}
for (i = 0; i < node->mNumChildren; i++)
processNode(node->mChildren[i], scene);
}
Mesh Model::processMesh(aiMesh* mesh, const aiScene* scene)
{
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::vector<Texture> textures;
unsigned int i;
for (i = 0; i < mesh->mNumVertices; i++)
{
Vertex vertex;
glm::vec3 v;
v.x = mesh->mVertices[i].x;
v.y = mesh->mVertices[i].y;
v.z = mesh->mVertices[i].z;
vertex.Position = v;
if (mesh->mNormals != NULL)
{
v.x = mesh->mNormals[i].x;
v.y = mesh->mNormals[i].y;
v.z = mesh->mNormals[i].z;
vertex.Normal = v;
}
if (mesh->mTangents != NULL)
{
v.x = mesh->mTangents[i].x;
v.y = mesh->mTangents[i].y;
v.z = mesh->mTangents[i].z;
vertex.Tangent = v;
}
if (mesh->mBitangents != NULL)
{
v.x = mesh->mBitangents[i].x;
v.y = mesh->mBitangents[i].y;
v.z = mesh->mBitangents[i].z;
vertex.Bitangent = v;
}
vertex.Color = glm::vec3(0.0f);
if (mesh->mTextureCoords[0]) { // does the mesh contains texture coordinates?
glm::vec2 vec;
vec.x = mesh->mTextureCoords[0][i].x;
vec.y = mesh->mTextureCoords[0][i].y;
vertex.TexCoord = vec;
}
else {
vertex.TexCoord = glm::vec2(0.0f);
}
vertices.push_back(vertex);
}
for (i = 0; i < mesh->mNumFaces; i++)
{
aiFace face = mesh->mFaces[i];
for (unsigned int j = 0; j < face.mNumIndices; j++)
indices.push_back(face.mIndices[j]);
}
if (mesh->mMaterialIndex >= 0)
{
aiMaterial* mat = scene->mMaterials[mesh->mMaterialIndex];
std::vector<Texture> diffuseMaps = loadMaterialTextures(mat, aiTextureType_DIFFUSE, TextureType::diffuse);
textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
std::vector<Texture> specularMaps = loadMaterialTextures(mat, aiTextureType_SPECULAR, TextureType::specular);
textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
std::vector<Texture> normalMaps = loadMaterialTextures(mat, aiTextureType_NORMALS, TextureType::normal);
textures.insert(textures.end(), normalMaps.begin(), normalMaps.end());
std::vector<Texture> heightMaps = loadMaterialTextures(mat, aiTextureType_HEIGHT, TextureType::height);
textures.insert(textures.end(), heightMaps.begin(), heightMaps.end());
}
return Mesh(vertices, indices, textures);
}
std::vector<Texture> Model::loadMaterialTextures(aiMaterial* mat, aiTextureType type, TextureType glmlType)
{
std::vector<Texture> textures;
for (unsigned int i = 0; i < mat->GetTextureCount(type); i++)
{
aiString str;
mat->GetTexture(type, i, &str);
bool loaded = false;
for (int j = 0; j < textures_loaded.size(); j++)
{
if (std::strcmp(textures_loaded[j].path.data(), str.C_Str()) == 0)
{
textures.push_back(textures_loaded[j]);
loaded = true;
break;
}
}
if (!loaded)
{
Texture texture;
texture.id = load_texture(directory + '/' + str.C_Str());
texture.type = glmlType;
texture.path = str.C_Str();
textures.push_back(texture);
textures_loaded.push_back(texture);
}
}
return textures;
}
static unsigned int glml::load_texture(const std::string path)
{
return glml::load_texture(path.c_str());
}
static unsigned int glml::load_texture(const char* path)
{
unsigned int texture = 0;
int width, height, nrChannels, format;
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 1: 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, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
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, GL_RGB, width, height, 0, format, GL_UNSIGNED_BYTE, data); // generates texture
glGenerateMipmap(GL_TEXTURE_2D);
}
else {
std::cerr << "Could not load texture '" << path << "'\n";
}
stbi_image_free(data);
return texture;
}

29
lessons/3. Model loading/1. Mesh/src/Model.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include <string>
#include "Mesh.h"
#include <vector>
#include "Shader.h"
#include <assimp/scene.h>
namespace glml
{
class Model {
public:
Model(const std::string path);
void Draw(Shader& shader) const;
private:
// model data
std::vector<Mesh> meshes;
std::string directory;
std::vector<Texture> textures_loaded;
void loadModel(const std::string path);
void processNode(aiNode* node, const aiScene* scene);
Mesh processMesh(aiMesh* mesh, const aiScene* scene);
std::vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, TextureType glmlType);
};
static unsigned int load_texture(const char* path);
static unsigned int load_texture(const std::string path);
}

119
lessons/3. Model loading/1. Mesh/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/3. Model loading/1. Mesh/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);
};

214
lessons/3. Model loading/1. Mesh/src/main.cpp Normal file
View File

@@ -0,0 +1,214 @@
#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 "Shader.h"
#include "Camera.h"
#include "Model.h"
#define TEXTURES_DIR "../../../../textures/"
#define MODELS_DIR "../../../../models/"
#define SHADERS_DIR "../src/shaders/"
using namespace std;
typedef unsigned int uint;
// 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);
int main(int argc, char** argv)
{
if (init() != 0)
return -1;
Shader lightingShader(SHADERS_DIR "glmlShader.vert", SHADERS_DIR "glmlShader.frag");
stbi_set_flip_vertically_on_load(1);
glml::Model backpack(MODELS_DIR "backpack/backpack.obj");
glEnable(GL_DEPTH_TEST);
/* ------------------ 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 ...
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lightingShader.Use();
// lightingShader.setVec3("light.position", lightPos);
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);
glm::mat4 model(1.0f);
glm::mat3 normalMatrix = glm::transpose(glm::inverse(model));
lightingShader.setMat4("view", view);
lightingShader.setMat4("projection", projection);
lightingShader.setMat4("model", model);
lightingShader.setMat3("normalMatrix", normalMatrix);
glm::vec3 lightColor = glm::vec3(1.0f);
glm::vec3 lightPos = glm::vec3(-1.13f, 2.0f, 2.0f);
lightingShader.setVec3("pointLights[0].position", lightPos);
// lightingShader.setVec3("spotLight.direction", myCamera.Front);
lightingShader.setVec3("pointLights[0].ambient_intensity", glm::vec3(0.1f));
lightingShader.setVec3("pointLights[0].diffuse_intensity", lightColor * glm::vec3(0.5f));
lightingShader.setVec3("pointLights[0].specular_intensity", lightColor * glm::vec3(1.0f));
lightingShader.setFloat("pointLights[0].constant", 1.0f);
lightingShader.setFloat("pointLights[0].linear", 0.07f);
lightingShader.setFloat("pointLights[0].quadratic", 0.032f);
// lightingShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(12.5f)));
// lightingShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(17.5f)));
lightingShader.setVec3("viewPos", myCamera.Position);
lightingShader.setFloat("material.shininess", 32.0f);
backpack.Draw(lightingShader);
// 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, "6. Multiple Lights", 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)
{
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, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
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, GL_RGB, 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);
return texture;
}

132
lessons/3. Model loading/1. Mesh/src/shaders/fragmentShader.frag Normal file
View File

@@ -0,0 +1,132 @@
#version 330 core
struct Material {
sampler2D diffuse_map;
sampler2D specular_map;
float shininess;
};
struct DirLight {
vec3 direction;
vec3 ambient_intensity;
vec3 diffuse_intensity;
vec3 specular_intensity;
};
struct PointLight {
vec3 position;
vec3 ambient_intensity;
vec3 diffuse_intensity;
vec3 specular_intensity;
float constant;
float linear;
float quadratic;
};
struct SpotLight {
vec3 position;
vec3 direction;
vec3 ambient_intensity;
vec3 diffuse_intensity;
vec3 specular_intensity;
float constant;
float linear;
float quadratic;
float cutOff;
float outerCutOff;
};
out vec4 FragColor;
uniform vec3 viewPos;
uniform Material material;
#define NR_POINT_LIGHTS 4
uniform SpotLight spotLight;
uniform DirLight dirLight;
uniform PointLight pointLights[NR_POINT_LIGHTS];
in vec3 Normal;
in vec3 FragPos;
in vec2 TexCoord;
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir);
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 viewDir, vec3 fragPos);
vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 viewDir, vec3 fragPos);
void main()
{
vec3 normal = normalize(Normal);
vec3 viewDir = normalize(viewPos - FragPos);
vec3 result = CalcDirLight(dirLight, normal, viewDir);
for (int i = 0; i < NR_POINT_LIGHTS; i++)
result += CalcPointLight(pointLights[i], normal, viewDir, FragPos);
result += CalcSpotLight(spotLight, normal, viewDir, FragPos);
FragColor = vec4(result, 1.0);
}
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
{
vec3 lightDir = normalize(-light.direction);
float diff = max(dot(lightDir, normal), 0.0f);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
vec3 ambient = light.ambient_intensity * vec3(texture(material.diffuse_map, TexCoord));
vec3 diffuse = light.diffuse_intensity * diff * vec3(texture(material.diffuse_map, TexCoord));
vec3 specular = light.specular_intensity * spec * vec3(texture(material.specular_map, TexCoord));
return (ambient + diffuse + specular);
}
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 viewDir, vec3 fragPos)
{
vec3 lightDir = normalize(light.position - fragPos); // direction towards light source
float diff = max(dot(lightDir, normal), 0.0f);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
vec3 ambient = light.ambient_intensity * vec3(texture(material.diffuse_map, TexCoord));
vec3 diffuse = light.diffuse_intensity * diff * vec3(texture(material.diffuse_map, TexCoord));
vec3 specular = light.specular_intensity * spec * vec3(texture(material.specular_map, TexCoord));
float frag_dist = length(light.position - fragPos); // fragment distance from light source position
float attenuation = 1.0 / (light.constant + light.linear * frag_dist + light.quadratic * frag_dist * frag_dist);
return (ambient + diffuse + specular) * attenuation;
}
vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 viewDir, vec3 fragPos)
{
vec3 lightDir = normalize(light.position - fragPos); // direction towards light source
float diff = max(dot(lightDir, normal), 0.0f);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
vec3 ambient = light.ambient_intensity * vec3(texture(material.diffuse_map, TexCoord));
vec3 diffuse = light.diffuse_intensity * diff * vec3(texture(material.diffuse_map, TexCoord));
vec3 specular = light.specular_intensity * spec * vec3(texture(material.specular_map, TexCoord));
float dist = length(light.position - FragPos);
float attenuation = 1.0 / (light.constant + light.linear * dist + light.quadratic * (dist * dist));
float theta = dot(lightDir, normalize(-light.direction));
float epsilon = light.cutOff - light.outerCutOff;
float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
//float intensity = smoothstep(0.0, 1.0, (theta - light.outerCutOff) / epsilon);
diffuse *= attenuation * intensity;
specular *= attenuation * intensity;
return (ambient + diffuse + specular);
}

132
lessons/3. Model loading/1. Mesh/src/shaders/glmlShader.frag Normal file
View File

@@ -0,0 +1,132 @@
#version 330 core
struct Material {
sampler2D texture_diffuse0;
sampler2D texture_diffuse1;
sampler2D texture_diffuse2;
sampler2D texture_specular0;
sampler2D texture_specular1;
sampler2D texture_specular2;
float shininess;
};
struct DirLight {
vec3 direction;
vec3 ambient_intensity;
vec3 diffuse_intensity;
vec3 specular_intensity;
};
struct PointLight {
vec3 position;
vec3 ambient_intensity;
vec3 diffuse_intensity;
vec3 specular_intensity;
float constant;
float linear;
float quadratic;
};
struct SpotLight {
vec3 position;
vec3 direction;
vec3 ambient_intensity;
vec3 diffuse_intensity;
vec3 specular_intensity;
float constant;
float linear;
float quadratic;
float cutOff;
float outerCutOff;
};
out vec4 FragColor;
uniform vec3 viewPos;
uniform Material material;
#define NR_POINT_LIGHTS 4
uniform SpotLight spotLight;
uniform DirLight dirLight;
uniform PointLight pointLights[NR_POINT_LIGHTS];
in vec3 Normal;
in vec3 FragPos;
in vec2 TexCoord;
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir);
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 viewDir, vec3 fragPos);
vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 viewDir, vec3 fragPos);
void main()
{
vec3 normal = normalize(Normal);
vec3 viewDir = normalize(viewPos - FragPos);
// vec3 result = CalcSpotLight(spotLight, normal, viewDir, FragPos);
vec3 result = CalcPointLight(pointLights[0], normal, viewDir, FragPos);
FragColor = vec4(result.rgb, 1.0);
}
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
{
vec3 lightDir = normalize(-light.direction);
float diff = max(dot(lightDir, normal), 0.0f);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
vec3 ambient = light.ambient_intensity * vec3(texture(material.texture_diffuse0, TexCoord));
vec3 diffuse = light.diffuse_intensity * diff * vec3(texture(material.texture_diffuse0, TexCoord));
vec3 specular = light.specular_intensity * spec * vec3(texture(material.texture_specular0, TexCoord));
return (ambient + diffuse + specular);
}
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 viewDir, vec3 fragPos)
{
vec3 lightDir = normalize(light.position - fragPos); // direction towards light source
float diff = max(dot(lightDir, normal), 0.0f);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
vec3 ambient = light.ambient_intensity * vec3(texture(material.texture_diffuse0, TexCoord));
vec3 diffuse = light.diffuse_intensity * diff * vec3(texture(material.texture_diffuse0, TexCoord));
vec3 specular = light.specular_intensity * spec * vec3(texture(material.texture_specular0, TexCoord));
float frag_dist = length(light.position - fragPos); // fragment distance from light source position
float attenuation = 1.0 / (light.constant + light.linear * frag_dist + light.quadratic * frag_dist * frag_dist);
return ambient + (diffuse + specular) * attenuation;
}
vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 viewDir, vec3 fragPos)
{
vec3 lightDir = normalize(light.position - fragPos); // direction towards light source
float diff = max(dot(lightDir, normal), 0.0f);
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
vec3 ambient = light.ambient_intensity * vec3(texture(material.texture_diffuse0, TexCoord));
vec3 diffuse = light.diffuse_intensity * diff * vec3(texture(material.texture_diffuse0, TexCoord));
vec3 specular = light.specular_intensity * spec * vec3(texture(material.texture_specular0, TexCoord));
float dist = length(light.position - FragPos);
float attenuation = 1.0 / (light.constant + light.linear * dist + light.quadratic * (dist * dist));
float theta = dot(lightDir, normalize(-light.direction));
float epsilon = light.cutOff - light.outerCutOff;
float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
//float intensity = smoothstep(0.0, 1.0, (theta - light.outerCutOff) / epsilon);
diffuse *= attenuation * intensity;
specular *= attenuation * intensity;
return (ambient + diffuse + specular);
}

24
lessons/3. Model loading/1. Mesh/src/shaders/glmlShader.vert Normal file
View File

@@ -0,0 +1,24 @@
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoord;
layout (location = 3) in vec3 aTangent;
layout (location = 4) in vec3 aBitangent;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
uniform mat3 normalMatrix;
out vec3 Normal;
out vec3 FragPos;
out vec2 TexCoord;
void main()
{
gl_Position = projection * view * model * vec4(aPos.xyz, 1.0);
Normal = normalMatrix * aNormal;
FragPos = vec3(model * vec4(aPos, 1.0));
TexCoord = aTexCoord;
}

10
lessons/3. Model loading/1. Mesh/src/shaders/lightSource.frag Normal file
View File

@@ -0,0 +1,10 @@
#version 330 core
out vec4 FragColor;
uniform vec3 lightColor;
void main()
{
FragColor = vec4(lightColor, 1.0f);
}

10
lessons/3. Model loading/1. Mesh/src/shaders/lightSource.vert Normal file
View File

@@ -0,0 +1,10 @@
#version 330 core
layout (location = 0) in vec3 aPos;
uniform mat4 PVM;
void main()
{
gl_Position = PVM * vec4(aPos.xyz, 1.0);
}

22
lessons/3. Model loading/1. Mesh/src/shaders/vertexShader.vert Normal file
View File

@@ -0,0 +1,22 @@
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoord;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
uniform mat3 normalMatrix;
out vec3 Normal;
out vec3 FragPos;
out vec2 TexCoord;
void main()
{
gl_Position = projection * view * model * vec4(aPos.xyz, 1.0);
Normal = normalMatrix * aNormal;
FragPos = vec3(model * vec4(aPos, 1.0));
TexCoord = aTexCoord;
}