abdelrahman/learnopengl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
68cc990650
learnopengl/src/main.cc

819 lines
27 KiB
C++
Raw Blame History

// GLAD
#include "glad/glad.h"
// STB Image
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
// GLM
#define GLM_ENABLE_EXPERIMENTAL
#include "glm/ext/matrix_transform.hpp"
#include "glm/ext/vector_float3.hpp"
#include "glm/gtc/type_ptr.hpp"
#include "glm/trigonometric.hpp"
#include "glm/gtx/rotate_vector.hpp"
#include "glm/gtx/string_cast.hpp"
// Assimp
#include "assimp/Importer.hpp"
#include "assimp/postprocess.h"
#include "assimp/scene.h"
#include "assimp/mesh.h"
#include "assimp/material.h"
#include "assimp/types.h"
// SDL
#include <SDL2/SDL.h>
#include <SDL2/SDL_timer.h>
#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_error.h>
#include <SDL2/SDL_video.h>
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_mouse.h>
#include <SDL2/SDL_keycode.h>
// STDLIB
#include <cstdint>
#include <cstdio>
#include <cmath>
#include <string>
#include <vector>
#define WINDOW_WIDTH 1280
#define WINDOW_HEIGHT 720
#define WINDOW_HALF_WIDTH 640
#define WINDOW_HALF_HEIGHT 360
#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)
#define clamp(v, a, b) (min(max(v, a), b))
enum exit_codes : int {
EXIT_CODE_SUCCESS,
EXIT_CODE_SDL_INIT_FAILED,
EXIT_CODE_WINDOW_CREATION_FAILED,
EXIT_CODE_OPENGL_CONTEXT_FAILED,
EXIT_CODE_GLAD_LOADER_FAILED,
EXIT_CODE_INCOMPLETE_FRAME_BUFFER,
};
class Shader {
public:
Shader(const std::string &vert_file, const std::string &frag_file);
~Shader();
void activate();
void set_int(const char *name, int value);
void set_float(const char *name, float value);
void set_vec3(const char *name, glm::vec3 vector);
void set_vec4(const char *name, glm::vec4 vector);
void set_mat3(const char *name, glm::mat3 matrix);
void set_mat4(const char *name, glm::mat4 matrix);
GLuint program;
private:
void link_program(GLuint vert, GLuint frag);
GLuint load_and_compile_shader(const std::string &filepath, GLenum shader_type);
std::string load_shader_from_file(const std::string &filepath);
static const char *get_shader_type_string(GLenum shader_type);
};
enum TextureType : unsigned char {
TEXTURE_TYPE_DIFFUSE,
TEXTURE_TYPE_SPECULAR,
};
class Texture2D {
public:
Texture2D(const char *filename, GLint texture_unit, TextureType type);
~Texture2D();
void activate() const;
std::string name(unsigned int index) const;
int width;
int height;
int channels;
const char *filename;
GLint texture_unit;
TextureType type;
private:
GLuint texture;
GLint format;
};
struct Vertex {
glm::vec3 position;
glm::vec3 normal;
glm::vec2 tex_coord;
};
class Mesh {
public:
std::vector<Vertex> vertices;
std::vector<GLuint> indices;
std::vector<Texture2D> textures;
Mesh(std::vector<Vertex> vertices, std::vector<GLuint> indices, std::vector<Texture2D> textures);
void draw(Shader &Shader);
private:
GLuint vao, vbo, ebo;
void setup_mesh();
};
class Model {
public:
Model(const char *path) {
load_model(path);
}
void draw(Shader &shader);
private:
std::vector<Texture2D> loaded_textures;
std::vector<Mesh> meshes;
std::string directory;
GLint texture_unit = GL_TEXTURE0;
void load_model(std::string path);
void process_node(aiNode *node, const aiScene *scene);
Mesh process_mesh(aiMesh *mesh, const aiScene *scene);
std::vector<Texture2D> load_material_textures(aiMaterial *mat, aiTextureType type);
};
struct FrameBuffer {
GLuint fbo;
GLuint color;
GLuint depth_stencil;
};
FrameBuffer create_frame_buffer(unsigned int width, unsigned int height);
void delete_frame_buffer(FrameBuffer &buffer);
int main() {
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
return EXIT_CODE_SDL_INIT_FAILED;
}
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_Window *window = SDL_CreateWindow("Window", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
if (!window) {
return EXIT_CODE_WINDOW_CREATION_FAILED;
}
SDL_GLContext context = SDL_GL_CreateContext(window);
if (!context) {
return EXIT_CODE_OPENGL_CONTEXT_FAILED;
}
if (gladLoadGLLoader(SDL_GL_GetProcAddress) == 0) {
return EXIT_CODE_GLAD_LOADER_FAILED;
}
SDL_SetRelativeMouseMode(SDL_TRUE);
SDL_WarpMouseInWindow(window, WINDOW_HALF_WIDTH, WINDOW_HALF_HEIGHT);
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
FrameBuffer offscreen_buffer = create_frame_buffer(WINDOW_WIDTH, WINDOW_HEIGHT);
std::vector<Vertex> vertices = {
// positions // normals // texture coords
Vertex{glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec2(0.0f, 1.0f)},
Vertex{glm::vec3( 0.5f, 0.5f, 0.5f), glm::vec3( 1.0f, 0.0f, 0.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3( 0.5f, 0.5f, -0.5f), glm::vec3( 1.0f, 0.0f, 0.0f), glm::vec2(1.0f, 1.0f)},
Vertex{glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec3( 0.0f, 0.0f, 1.0f), glm::vec2(0.0f, 1.0f)},
Vertex{glm::vec3( 0.5f, -0.5f, 0.5f), glm::vec3( 1.0f, 0.0f, 0.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3( 0.5f, -0.5f, -0.5f), glm::vec3( 0.0f, -1.0f, 0.0f), glm::vec2(1.0f, 1.0f)},
Vertex{glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3( 0.0f, 0.0f, -1.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3( 0.5f, -0.5f, 0.5f), glm::vec3( 0.0f, 0.0f, 1.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3( 0.0f, -1.0f, 0.0f), glm::vec2(0.0f, 1.0f)},
Vertex{glm::vec3( 0.5f, 0.5f, 0.5f), glm::vec3( 0.0f, 0.0f, 1.0f), glm::vec2(1.0f, 1.0f)},
Vertex{glm::vec3( 0.5f, -0.5f, 0.5f), glm::vec3( 0.0f, -1.0f, 0.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec3( 0.0f, -1.0f, 0.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3( 0.5f, 0.5f, -0.5f), glm::vec3( 0.0f, 0.0f, -1.0f), glm::vec2(1.0f, 1.0f)},
Vertex{glm::vec3( 0.5f, 0.5f, 0.5f), glm::vec3( 0.0f, 1.0f, 0.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3( 0.5f, -0.5f, -0.5f), glm::vec3( 0.0f, 0.0f, -1.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec3( 0.0f, 1.0f, 0.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec3( 0.0f, 1.0f, 0.0f), glm::vec2(0.0f, 1.0f)},
Vertex{glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec3( 0.0f, 0.0f, 1.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3(-0.5f, -0.5f, 0.5f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec3( 0.0f, 0.0f, -1.0f), glm::vec2(0.0f, 1.0f)},
Vertex{glm::vec3(-0.5f, 0.5f, -0.5f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec2(1.0f, 1.0f)},
Vertex{glm::vec3( 0.5f, 0.5f, -0.5f), glm::vec3( 0.0f, 1.0f, 0.0f), glm::vec2(1.0f, 1.0f)},
Vertex{glm::vec3(-0.5f, 0.5f, 0.5f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3( 0.5f, -0.5f, -0.5f), glm::vec3( 1.0f, 0.0f, 0.0f), glm::vec2(0.0f, 1.0f)},
};
std::vector<GLuint> indices = {
6, 14, 12,
12, 19, 6,
17, 7, 9,
9, 3, 17,
22, 20, 0,
0, 18, 22,
1, 2, 23,
23, 4, 1,
8, 5, 10,
10, 11, 8,
16, 21, 13,
13, 15, 16
};
Model backpack = {"models/suzanne/suzanne.obj"};
Mesh light = {vertices, indices, {}};
std::vector<Vertex> screen_vertices = {
Vertex{glm::vec3(-1.0f, -1.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec2(0.0f, 0.0f)},
Vertex{glm::vec3( 1.0f, -1.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec2(1.0f, 0.0f)},
Vertex{glm::vec3(-1.0f, 1.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec2(0.0f, 1.0f)},
Vertex{glm::vec3( 1.0f, 1.0f, 0.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec2(1.0f, 1.0f)},
};
std::vector<GLuint> screen_indices = {
0, 1, 2,
2, 1, 3,
};
Mesh screen = {screen_vertices, screen_indices, {}};
Shader main_shader {"shaders/vert.glsl", "shaders/frag.glsl"};
Shader light_shader {"shaders/vert.glsl", "shaders/light_frag.glsl"};
Shader post_processing {"shaders/pp_vert.glsl", "shaders/pp_frag.glsl"};
const float camera_speed = 25.0f;
glm::vec3 camera_position = glm::vec3(-2.0f, 0.0f, 6.0f);
glm::vec3 camera_forward = glm::vec3(0.0f);
glm::vec3 world_up = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 light_ambient = glm::vec3(0.2f, 0.2f, 0.2f);
glm::vec3 light_diffuse = glm::vec3(0.75f, 0.75f, 0.75f);
glm::vec3 light_specular = glm::vec3(1.0f, 1.0f, 1.0f);
float yaw = -70.0f;
float pitch = 0.0f;
glm::mat4 model = glm::mat4(1.0f);
glm::mat4 view = glm::mat4(1.0f);
glm::mat4 projection = glm::perspective(glm::radians(45.0f), (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT, 0.1f, 100.0f);
glm::mat3 normal_mat = glm::mat3(1.0f);
main_shader.set_mat4 ("projection", projection);
main_shader.set_float("material.shininess", 32.0f);
light_shader.set_mat4("projection", projection);
std::vector<glm::vec3> point_light_positions = {
glm::vec3( 0.7f, 0.2f, 2.0f),
glm::vec3( 2.3f, -3.3f, -4.0f),
glm::vec3(-4.0f, 2.0f, -12.0f),
glm::vec3( 1.0f, 0.0f, -18.0f)
};
// Setup lights
main_shader.set_vec3("directional_light.direction", glm::vec3(-0.2f, -1.0f, -0.3f));
main_shader.set_vec3("directional_light.ambient", light_ambient);
main_shader.set_vec3("directional_light.diffuse", light_diffuse * 0.25f);
main_shader.set_vec3("directional_light.specular", light_specular);
main_shader.set_vec3("spot_light.ambient", light_ambient);
main_shader.set_vec3("spot_light.diffuse", light_diffuse * 0.5f);
main_shader.set_vec3("spot_light.specular", light_specular * 0.25f);
for (int i = 0; i < point_light_positions.size(); ++i) {
char base[256] = {0};
char position[512] = {0};
char ambient[512] = {0};
char diffuse[512] = {0};
char specular[512] = {0};
char constant[512] = {0};
char linear[512] = {0};
char quadratic[512] = {0};
snprintf(base, sizeof(base) - 1, "point_lights[%d]", i);
snprintf(position, sizeof(position) - 1, "%s.position", base);
snprintf(ambient, sizeof(ambient) - 1, "%s.ambient", base);
snprintf(diffuse, sizeof(diffuse) - 1, "%s.diffuse", base);
snprintf(specular, sizeof(specular) - 1, "%s.specular", base);
snprintf(constant, sizeof(constant) - 1, "%s.constant", base);
snprintf(linear, sizeof(linear) - 1, "%s.linear", base);
snprintf(quadratic, sizeof(quadratic) - 1, "%s.quadratic", base);
main_shader.set_vec3(position, point_light_positions[i]);
main_shader.set_vec3(ambient, light_ambient);
main_shader.set_vec3(diffuse, light_diffuse * 0.25f);
main_shader.set_vec3(specular, light_specular * 0.5f);
main_shader.set_float(constant, 1.0f);
main_shader.set_float(linear, 0.09f);
main_shader.set_float(quadratic, 0.032f);
memset(base, 0, sizeof(base));
memset(position, 0, sizeof(position));
memset(ambient, 0, sizeof(ambient));
memset(diffuse, 0, sizeof(diffuse));
memset(specular, 0, sizeof(specular));
memset(constant, 0, sizeof(constant));
memset(linear, 0, sizeof(linear));
memset(quadratic, 0, sizeof(quadratic));
}
const float sensitivity = 0.1f;
int last_mouse_x = WINDOW_HALF_WIDTH;
int last_mouse_y = WINDOW_HALF_HEIGHT;
uint32_t last_frame = SDL_GetTicks();
float delta = 0.0f;
bool running = true;
SDL_Event event = {};
while (running) {
uint32_t ticks = SDL_GetTicks();
delta = (ticks - last_frame) * 0.001f;
last_frame = ticks;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
running = false;
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE) {
running = false;
} else if (event.key.keysym.sym == SDLK_w) {
camera_position += camera_speed * delta * camera_forward;
} else if (event.key.keysym.sym == SDLK_s) {
camera_position -= camera_speed * delta * camera_forward;
} else if (event.key.keysym.sym == SDLK_d) {
camera_position += camera_speed * delta * glm::normalize(glm::cross(camera_forward, world_up));
} else if (event.key.keysym.sym == SDLK_a) {
camera_position -= camera_speed * delta * glm::normalize(glm::cross(camera_forward, world_up));
}
break;
case SDL_MOUSEMOTION: {
float x_offset = event.motion.xrel;
float y_offset = -event.motion.yrel;
last_mouse_x = last_mouse_x + event.motion.xrel;
last_mouse_y = last_mouse_y + event.motion.yrel;
x_offset *= sensitivity;
y_offset *= sensitivity;
yaw += x_offset;
pitch += y_offset;
if(pitch > 89.0f) {
pitch = 89.0f;
}
if(pitch < -89.0f) {
pitch = -89.0f;
}
}
break;
case SDL_WINDOWEVENT:
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
SDL_Window *wnd = SDL_GetWindowFromID(event.window.windowID);
if (!wnd) {
continue;
}
int w, h;
SDL_GL_GetDrawableSize(wnd, &w, &h);
glViewport(0, 0, w, h);
SDL_WarpMouseInWindow(wnd, (int)(w * 0.5f), (int)(h * 0.5f));
// Recreate offscreen frame buffer
delete_frame_buffer(offscreen_buffer);
offscreen_buffer = create_frame_buffer(w, h);
}
break;
}
}
camera_forward.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
camera_forward.y = sin(glm::radians(pitch));
camera_forward.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
camera_forward = glm::normalize(camera_forward);
view = glm::lookAt(camera_position, camera_position + camera_forward, world_up);
main_shader.set_vec3("camera_position", camera_position);
main_shader.set_vec3("spot_light.position", camera_position);
main_shader.set_vec3("spot_light.direction", camera_forward);
main_shader.set_float("spot_light.cutoff", glm::cos(glm::radians(12.5)));
main_shader.set_float("spot_light.outer_cutoff", glm::cos(glm::radians(17.5)));
main_shader.set_mat4("view", view);
light_shader.set_mat4("view", view);
// Main render pass
glBindFramebuffer(GL_FRAMEBUFFER, offscreen_buffer.fbo);
glClearColor(0.04f, 0.08f, 0.08f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
model = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
normal_mat = glm::transpose(glm::inverse(model));
main_shader.activate();
main_shader.set_mat4("model", model);
main_shader.set_mat3("normal_mat", normal_mat);
backpack.draw(main_shader);
// Draw light source
for (int i = 0; i < point_light_positions.size(); ++i) {
model = glm::translate(glm::mat4(1.0f), point_light_positions[i]);
model = glm::scale(model, glm::vec3(0.2f));
light_shader.activate();
light_shader.set_mat4("model", model);
light_shader.set_vec3("light_diffuse", light_diffuse);
light.draw(light_shader);
}
// wireframe mode
// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Post processing pass
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
post_processing.activate();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, offscreen_buffer.color);
post_processing.set_int("image_texture", 0);
screen.draw(post_processing);
SDL_GL_SwapWindow(window);
}
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
SDL_Quit();
return EXIT_CODE_SUCCESS;
}
Shader::Shader(const std::string &vert_file, const std::string &frag_file) {
GLuint vert = load_and_compile_shader(vert_file, GL_VERTEX_SHADER);
GLuint frag = load_and_compile_shader(frag_file, GL_FRAGMENT_SHADER);
link_program(vert, frag);
glDeleteShader(vert);
glDeleteShader(frag);
}
Shader::~Shader() {
if (program > 0) {
glDeleteProgram(program);
}
}
void Shader::activate() {
if (program > 0) {
glUseProgram(program);
}
}
void Shader::set_int(const char *name, int value) {
activate();
glUniform1i(glGetUniformLocation(program, name), value);
}
void Shader::set_float(const char *name, float value) {
activate();
glUniform1f(glGetUniformLocation(program, name), value);
}
void Shader::set_vec3(const char *name, glm::vec3 vector) {
activate();
glUniform3f(glGetUniformLocation(program, name), vector.x, vector.y, vector.z);
}
void Shader::set_vec4(const char *name, glm::vec4 vector) {
activate();
glUniform4f(glGetUniformLocation(program, name), vector.x, vector.y, vector.z, vector.w);
}
void Shader::set_mat3(const char *name, glm::mat3 matrix) {
activate();
glUniformMatrix3fv(glGetUniformLocation(program, name), 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::set_mat4(const char *name, glm::mat4 matrix) {
activate();
glUniformMatrix4fv(glGetUniformLocation(program, name), 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::link_program(GLuint vert, GLuint frag) {
program = glCreateProgram();
glAttachShader(program, vert);
glAttachShader(program, frag);
glLinkProgram(program);
GLint program_linked;
glGetProgramiv(program, GL_LINK_STATUS, &program_linked);
if (program_linked != GL_TRUE)
{
GLsizei log_length = 0;
GLchar message[1024];
glGetProgramInfoLog(program, 1024, &log_length, message);
printf("Failed to link program: %s\n", message);
program = 0;
}
}
GLuint Shader::load_and_compile_shader(const std::string &filepath, GLenum shader_type) {
std::string src = load_shader_from_file(filepath);
const char *shader_src = src.c_str();
GLuint shader = glCreateShader(shader_type);
glShaderSource(shader, 1, &shader_src, NULL);
glCompileShader(shader);
GLint shader_compiled;
glGetShaderiv(shader, GL_COMPILE_STATUS, &shader_compiled);
if (shader_compiled != GL_TRUE)
{
GLsizei log_length = 0;
GLchar message[1024];
glGetShaderInfoLog(shader, 1024, &log_length, message);
printf("Failed to compile %s shader: %s\n", get_shader_type_string(shader_type), message);
return 0;
}
return shader;
}
std::string Shader::load_shader_from_file(const std::string &filepath) {
FILE *fp = fopen(filepath.c_str(), "r");
if (!fp) {
return "";
}
std::string output = {};
char buf[1024] = {0};
while (fgets(buf, sizeof(buf), fp)) {
output += buf;
}
return output;
}
const char *Shader::get_shader_type_string(GLenum shader_type) {
const char *output;
switch (shader_type) {
case GL_COMPUTE_SHADER:
output = "compute";
break;
case GL_VERTEX_SHADER:
output = "vertex";
break;
case GL_TESS_CONTROL_SHADER:
output = "tess_control";
break;
case GL_TESS_EVALUATION_SHADER:
output = "tess_evaluation";
break;
case GL_GEOMETRY_SHADER:
output = "geometry";
break;
case GL_FRAGMENT_SHADER:
output = "fragment";
break;
default:
output = "UNKNOWN";
break;
}
return output;
}
Texture2D::Texture2D(const char *filename, GLint texture_unit, TextureType type) : filename(filename), texture_unit(texture_unit), type(type) {
uint8_t *image = stbi_load(filename, &width, &height, &channels, 0);
if (!image) {
return;
}
// TODO (Abdelrahman): This doesn't handle all formats
format = channels > 3 ? GL_RGBA : GL_RGB;
glGenTextures(1, &texture);
activate();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
stbi_image_free(image);
}
Texture2D::~Texture2D() {}
void Texture2D::activate() const {
glActiveTexture(texture_unit);
glBindTexture(GL_TEXTURE_2D, texture);
}
std::string Texture2D::name(unsigned int index) const {
std::string output = "material.";
switch (type) {
case TEXTURE_TYPE_DIFFUSE:
output += "diffuse";
break;
case TEXTURE_TYPE_SPECULAR:
output += "specular";
break;
}
output += std::to_string(index);
return output.c_str();
}
Mesh::Mesh(std::vector<Vertex> vertices, std::vector<GLuint> indices, std::vector<Texture2D> textures)
: vertices(vertices), indices(indices), textures(textures) {
setup_mesh();
}
void Mesh::setup_mesh() {
glGenVertexArrays(1, &vao);
glGenBuffers(1, &ebo);
glGenBuffers(1, &vbo);
glBindVertexArray(vao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint), indices.data(), GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)(offsetof(Vertex, normal)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void *)(offsetof(Vertex, tex_coord)));
glEnableVertexAttribArray(2);
}
void Mesh::draw(Shader &shader) {
unsigned int diffuse = 1;
unsigned int specular = 1;
unsigned int index;
for (int i = 0; i < textures.size(); ++i) {
const Texture2D &texture = textures[i];
index = texture.type == TEXTURE_TYPE_DIFFUSE ? diffuse++ : specular++;
shader.set_int(texture.name(index).c_str(), texture.texture_unit - GL_TEXTURE0);
texture.activate();
}
glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, (void *)0);
glBindVertexArray(0);
}
void Model::draw(Shader &shader) {
for (int i = 0; i < meshes.size(); ++i) {
meshes[i].draw(shader);
}
}
void Model::load_model(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) {
printf("Failed to load model: %s. Error: %s\n", path.c_str(), importer.GetErrorString());
return;
}
directory = path.substr(0, path.find_last_of('/'));
process_node(scene->mRootNode, scene);
}
void Model::process_node(aiNode *node, const aiScene *scene) {
for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
aiMesh *mesh = scene->mMeshes[node->mMeshes[i]];
meshes.push_back(process_mesh(mesh, scene));
}
for (unsigned int i = 0; i < node->mNumChildren; ++i) {
process_node(node->mChildren[i], scene);
}
}
Mesh Model::process_mesh(aiMesh *mesh, const aiScene *scene) {
std::vector<Vertex> vertices;
std::vector<GLuint> indices;
std::vector<Texture2D> textures;
for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
Vertex vertex;
vertex.position = glm::vec3(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z);
vertex.normal = glm::vec3(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);
if (mesh->mTextureCoords[0]) {
vertex.tex_coord = glm::vec2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y);
} else {
vertex.tex_coord = glm::vec2(0.0f, 0.0f);
}
vertices.push_back(vertex);
}
for (unsigned int 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 *material = scene->mMaterials[mesh->mMaterialIndex];
std::vector<Texture2D> diffuse_maps = load_material_textures(material, aiTextureType_DIFFUSE);
textures.insert(textures.end(), diffuse_maps.begin(), diffuse_maps.end());
std::vector<Texture2D> specular_maps = load_material_textures(material, aiTextureType_SPECULAR);
textures.insert(textures.end(), specular_maps.begin(), specular_maps.end());
}
return Mesh(vertices, indices, textures);
}
std::vector<Texture2D> Model::load_material_textures(aiMaterial *material, aiTextureType type) {
std::vector<Texture2D> textures;
for (unsigned int i = 0; i < material->GetTextureCount(type); ++i) {
aiString path;
material->GetTexture(type, i, &path);
std::string absolute_path = directory + '/' + path.C_Str();
bool skip = false;
for (unsigned int j = 0; j < loaded_textures.size(); ++j) {
if (std::strcmp(loaded_textures[j].filename, absolute_path.c_str()) == 0) {
textures.push_back(loaded_textures[j]);
skip = true;
break;
}
}
if (!skip) {
TextureType tex_type = type == aiTextureType_DIFFUSE ? TEXTURE_TYPE_DIFFUSE : TEXTURE_TYPE_SPECULAR;
Texture2D texture = {absolute_path.c_str(), texture_unit++, tex_type};
textures.push_back(texture);
}
}
return textures;
}
FrameBuffer create_frame_buffer(unsigned int width, unsigned int height) {
FrameBuffer buffer = {};
glGenFramebuffers(1, &buffer.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, buffer.fbo);
// Create color texture
glGenTextures(1, &buffer.color);
glBindTexture(GL_TEXTURE_2D, buffer.color);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer.color, 0);
// Create depth and stencil buffers
glGenRenderbuffers(1, &buffer.depth_stencil);
glBindRenderbuffer(GL_RENDERBUFFER, buffer.depth_stencil);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, buffer.depth_stencil);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("Incomplete frame buffer\n");
exit(EXIT_CODE_INCOMPLETE_FRAME_BUFFER);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
return buffer;
}
void delete_frame_buffer(FrameBuffer &buffer) {
glDeleteFramebuffers(1, &buffer.fbo);
glDeleteTextures(1, &buffer.color);
glDeleteRenderbuffers(1, &buffer.depth_stencil);
}
Reference in New Issue View Git Blame Copy Permalink