diff options
Diffstat (limited to 'source/lessons')
| -rw-r--r-- | source/lessons/lighting/README.md | 12 | ||||
| -rw-r--r-- | source/lessons/lighting/main.cpp | 1134 | ||||
| -rw-r--r-- | source/lessons/lighting/shaders/light_source.fs.glsl | 5 | ||||
| -rw-r--r-- | source/lessons/lighting/shaders/light_source.vs.glsl | 10 | ||||
| -rw-r--r-- | source/lessons/lighting/shaders/light_subject.fs.glsl | 200 | ||||
| -rw-r--r-- | source/lessons/lighting/shaders/light_subject.vs.glsl | 21 | ||||
| -rw-r--r-- | source/lessons/models/main.cpp | 710 | ||||
| -rw-r--r-- | source/lessons/models/math.h | 394 | ||||
| -rw-r--r-- | source/lessons/models/shaders/model/model.fs.glsl | 152 | ||||
| -rw-r--r-- | source/lessons/models/shaders/model/model.vs.glsl | 25 |
10 files changed, 2663 insertions, 0 deletions
diff --git a/source/lessons/lighting/README.md b/source/lessons/lighting/README.md new file mode 100644 index 0000000..233d351 --- /dev/null +++ b/source/lessons/lighting/README.md @@ -0,0 +1,12 @@ +# Lighting + +This contains state of the codebase up until the lighting lessons from learnopengl +Everything is in a very minimal state, and mostly all contained in the main.cpp +Several maths functions and lighting functions are present. + +In the shaders, the light_subject shader contains code for creating multiple types of lights. This will hopefully be useful moving +forward. + +The rest is pretty messy and I have intentionally avoided abstracting away anything other than to save me the hassle of +declaring stuff. The functions that so far exist, exist for very specific things and are just lines of procedural code +that I did not want to write again and again. diff --git a/source/lessons/lighting/main.cpp b/source/lessons/lighting/main.cpp new file mode 100644 index 0000000..6cb5b7e --- /dev/null +++ b/source/lessons/lighting/main.cpp @@ -0,0 +1,1134 @@ +#include <stdio.h> +#include <SDL2/SDL.h> +#include <glad/glad.h> + +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" + +/* @lookup: +* - I do not understand how floating point numbers work, so I should probably look into that. +* - The normal matrix calculation in the fragment shader for the object affected by light has been mainly copied. +* I have tried to understand the formula, and whilst it made some sense, it is not fully clear to me, and I cannot picture it yet. +* Revisit the derivation for the normal matrix some time in the future. +* - Lookup the derivation of the formula for reflecting a vector about a normal. I am doing that for specular lighting, but the learnopengl tutorial +* just uses a glsl reflect formula, and at the time of writing it is also very late so I am not in the mood or position to look into it at present. +* - One of the things I have observed with specular lights is that the circle/specular highlight follows the camera (me) when I move. I would like to figure +* out a way by which this does not happen and it remains fixed on the object, at the angle at which it hits. All of this will be made complicated by the fact +* that ofcourse everything is actually happening from the cameras' perspective. I would still love to figure this out. +*/ + +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; + +typedef int8_t s8; +typedef int16_t s16; +typedef int32_t s32; +typedef int64_t s64; + +typedef float r32; +typedef double r64; + +typedef u8 b8; + +// =========== Shader Loading ============= + +unsigned int gl_create_vertex_shader(char* vertex_shader_source) +{ + unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL); + glCompileShader(vertex_shader); + + int success; + char info_log[512]; + glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success); + if (!success) + { + glGetShaderInfoLog(vertex_shader, 512, NULL, info_log); + printf("================================\n"); + printf("vertex shader compilation failed:\n%s\n", info_log); + } + + return vertex_shader; +} + +unsigned int gl_create_fragment_shader(char* fragment_shader_source) +{ + unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL); + glCompileShader(fragment_shader); + + int success; + char info_log[512]; + glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success); + if (!success) + { + glGetShaderInfoLog(fragment_shader, 512, NULL, info_log); + printf("================================\n"); + printf("fragment shader compilation failed:\n%s\n", info_log); + } + + return fragment_shader; +} + +unsigned int gl_create_shader_program(unsigned int vertex_shader, unsigned int fragment_shader) +{ + unsigned int shader_program = glCreateProgram(); + + glAttachShader(shader_program, vertex_shader); + glAttachShader(shader_program, fragment_shader); + glLinkProgram(shader_program); + + int success; + char info_log[512]; + glGetProgramiv(shader_program, GL_LINK_STATUS, &success); + if (!success) + { + glGetProgramInfoLog(shader_program, 512, NULL, info_log); + printf("================================\n"); + printf("shader program linking failed:\n%s\n", info_log); + } + + glDeleteShader(vertex_shader); + glDeleteShader(fragment_shader); + + return shader_program; +} + +int platform_read_file() +{ + return 0; +} + +int platform_write_file() +{ + return 0; +} + +// =========================================================== MATH ================================================== +#define PI 3.14159265358979323846264338327950288f +#define Square(x) ((x)*(x)) +#define To_Radian(x) ((x) * PI / 180.0f) +#define To_Degree(x) ((x) * 180.0f / PI) + +r32 clampf(r32 x, r32 bottom, r32 top) +{ + if (x < bottom) + { + x = bottom; + } + else if (x > top) + { + x = top; + } + + return x; +} + +// ==== Vector Math ==== + +union Vec3 { + struct { + r32 x; + r32 y; + r32 z; + }; + r32 data[3]; +}; + +union Vec4 { + struct { + r32 x; + r32 y; + r32 z; + r32 w; + }; + r32 data[4]; +}; + +union Mat4 { + Vec4 xyzw[4]; + r32 data[4][4]; + r32 buffer[16]; +}; + +// ========================================================== Vec3 ========================================================== + +Vec3 init3v(r32 x, r32 y, r32 z) +{ + Vec3 res; + res.x = x; + res.y = y; + res.z = z; + + return res; +} + +Vec3 scaler_add3v(Vec3 vec, r32 scaler) +{ + Vec3 res; + res.x = vec.x + scaler; + res.y = vec.y + scaler; + res.z = vec.z + scaler; + + return res; +} + +Vec3 scaler_multiply3v(Vec3 vec, r32 scaler) +{ + Vec3 res; + res.x = vec.x * scaler; + res.y = vec.y * scaler; + res.z = vec.z * scaler; + + return res; +} + +Vec3 scaler_divide3v(Vec3 vec, r32 scaler) +{ + Vec3 res; + res.x = vec.x / scaler; + res.y = vec.y / scaler; + res.z = vec.z / scaler; + + return res; +} + + +Vec3 add3v(Vec3 a, Vec3 b) +{ + Vec3 res; + res.x = a.x + b.x; + res.y = a.y + b.y; + res.z = a.z + b.z; + + return res; +} + +Vec3 subtract3v(Vec3 a, Vec3 b) +{ + Vec3 res; + res.x = a.x - b.x; + res.y = a.y - b.y; + res.z = a.z - b.z; + + return res; +} + +r32 dot_multiply3v(Vec3 a, Vec3 b) +{ + r32 x = a.x * b.x; + r32 y = a.y * b.y; + r32 z = a.z * b.z; + + r32 res = x + y + z; + + return res; +} + +r32 magnitude3v(Vec3 vec) +{ + r32 res = sqrtf(Square(vec.x) + Square(vec.y) + Square(vec.z)); + return res; +} + +Vec3 normalize3v(Vec3 vec) +{ + r32 magnitude = magnitude3v(vec); + Vec3 res = scaler_divide3v(vec, magnitude); + return res; +} + +#ifndef FUN_CALCS +r32 angle3v(Vec3 a, Vec3 b) +{ + Vec3 a_norm = normalize3v(a); + Vec3 b_norm = normalize3v(b); + + r32 dot_product = dot_multiply3v(a_norm, b_norm); + r32 res = acosf(dot_product); + + return res; +} +#endif + +Vec3 cross_multiply3v(Vec3 a, Vec3 b) +{ + Vec3 res; + res.x = (a.y * b.z) - (a.z * b.y); + res.y = (a.z * b.x) - (a.x * b.z); + res.z = (a.x * b.y) - (a.y * b.x); + + return res; +} + +// ============================================== Vec4, Mat4 ============================================== + +Vec4 init4v(r32 x, r32 y, r32 z, r32 w) +{ + Vec4 res; + res.x = x; + res.y = y; + res.z = z; + res.w = w; + + return res; +} + +Mat4 init_value4m(r32 value) +{ + Mat4 res = {0}; + res.data[0][0] = value; + res.data[1][1] = value; + res.data[2][2] = value; + res.data[3][3] = value; + + return res; +} + +// @note: These operations are just defined and not expressed. They are kept here for completeness sake BUT +// since I have not had to do anything related to these, I have not created them. +Vec4 scaler_add4v(Vec4 vec, r32 scaler); +Vec4 scaler_subtract4v(Vec4 vec, r32 scaler); +Vec4 scaler_multiply4v(Vec4 vec, r32 scaler); +Vec4 scaler_divide4v(Vec4 vec, r32 scaler); +Vec4 add4v(Vec4 a, Vec4 b); +Vec4 subtract4v(Vec4 a, Vec4 b); +Vec4 dot_multiply4v(Vec4 a, Vec4 b); + +Mat4 add4m(Mat4 a, Mat4 b) +{ + Mat4 res; + // row 0 + res.data[0][0] = a.data[0][0] + b.data[0][0]; + res.data[0][1] = a.data[0][1] + b.data[0][1]; + res.data[0][2] = a.data[0][2] + b.data[0][2]; + res.data[0][3] = a.data[0][3] + b.data[0][3]; + // row 1 + res.data[1][0] = a.data[1][0] + b.data[1][0]; + res.data[1][1] = a.data[1][1] + b.data[1][1]; + res.data[1][2] = a.data[1][2] + b.data[1][2]; + res.data[1][3] = a.data[1][3] + b.data[1][3]; + // row 2 + res.data[2][0] = a.data[2][0] + b.data[2][0]; + res.data[2][1] = a.data[2][1] + b.data[2][1]; + res.data[2][2] = a.data[2][2] + b.data[2][2]; + res.data[2][3] = a.data[2][3] + b.data[2][3]; + // row 3 + res.data[3][0] = a.data[3][0] + b.data[3][0]; + res.data[3][1] = a.data[3][1] + b.data[3][1]; + res.data[3][2] = a.data[3][2] + b.data[3][2]; + res.data[3][3] = a.data[3][3] + b.data[3][3]; + + return res; +} + +Mat4 subtract4m(Mat4 a, Mat4 b) +{ + Mat4 res; + // row 0 + res.data[0][0] = a.data[0][0] - b.data[0][0]; + res.data[0][1] = a.data[0][1] - b.data[0][1]; + res.data[0][2] = a.data[0][2] - b.data[0][2]; + res.data[0][3] = a.data[0][3] - b.data[0][3]; + // row 1 + res.data[1][0] = a.data[1][0] - b.data[1][0]; + res.data[1][1] = a.data[1][1] - b.data[1][1]; + res.data[1][2] = a.data[1][2] - b.data[1][2]; + res.data[1][3] = a.data[1][3] - b.data[1][3]; + // row 2 + res.data[2][0] = a.data[2][0] - b.data[2][0]; + res.data[2][1] = a.data[2][1] - b.data[2][1]; + res.data[2][2] = a.data[2][2] - b.data[2][2]; + res.data[2][3] = a.data[2][3] - b.data[2][3]; + // row 3 + res.data[3][0] = a.data[3][0] - b.data[3][0]; + res.data[3][1] = a.data[3][1] - b.data[3][1]; + res.data[3][2] = a.data[3][2] - b.data[3][2]; + res.data[3][3] = a.data[3][3] - b.data[3][3]; + + return res; +} + +Vec4 multiply4vm(Vec4 vec, Mat4 mat) +{ + /* + * @note: Incase I get confused about this in the future. + * + * Everything is row-order, which means that things in memory are laid out row first. So with a sample matrix + * we have this order in memory: r1c1 r1c2 r1c3 r1c4 r2c1 ... (r = row, c = column). The same holds true for + * vectors. (maybe move this explanation to the top) + * + * Now, multiply4vm will multiply a vector with a matrix. Conventionally that does not make any sense as + * a vector is usually 4x1 and a matrix ix 4x4. + * What this function considers a vector, while it is a vector, it is infact a row from a matrix, which + * means that the vector is 1x4 and the matrix is 4x4. + * + * The function is meant to supplement the matrix multiplication process to alleviate the multiple lines of code + * we have to write when multiplying the row of a left matrix to each column of the right matrix + */ + Vec4 res = { 0 }; + res.x = (mat.data[0][0] * vec.x) + (mat.data[0][1] * vec.y) + (mat.data[0][2] * vec.z) + (mat.data[0][3] * vec.w); + res.y = (mat.data[1][0] * vec.x) + (mat.data[1][1] * vec.y) + (mat.data[1][2] * vec.z) + (mat.data[1][3] * vec.w); + res.z = (mat.data[2][0] * vec.x) + (mat.data[2][1] * vec.y) + (mat.data[2][2] * vec.z) + (mat.data[2][3] * vec.w); + res.w = (mat.data[3][0] * vec.x) + (mat.data[3][1] * vec.y) + (mat.data[3][2] * vec.z) + (mat.data[3][3] * vec.w); + + return res; +} + +Mat4 multiply4m(Mat4 a, Mat4 b) +{ + Mat4 res = { 0 }; + + res.xyzw[0] = multiply4vm(a.xyzw[0], b); + res.xyzw[1] = multiply4vm(a.xyzw[1], b); + res.xyzw[2] = multiply4vm(a.xyzw[2], b); + res.xyzw[3] = multiply4vm(a.xyzw[3], b); + + return res; +} + +// ==== Matrix Transformation ==== + +Mat4 scaling_matrix4m(r32 x, r32 y, r32 z) // generates a 4x4 scaling matrix for scaling each of the x,y,z axis +{ + Mat4 res = init_value4m(1.0f); + res.data[0][0] = x; + res.data[1][1] = y; + res.data[2][2] = z; + + return res; +} + +Mat4 translation_matrix4m(r32 x, r32 y, r32 z) // generates a 4x4 translation matrix for translation along each of the x,y,z axis +{ + Mat4 res = init_value4m(1.0f); + res.data[0][3] = x; + res.data[1][3] = y; + res.data[2][3] = z; + + return res; +} + +Mat4 rotation_matrix4m(r32 angle_radians, Vec3 axis) // generates a 4x4 rotation matrix for rotation along each of the x,y,z axis +{ + Mat4 res = init_value4m(1.0f); + axis = normalize3v(axis); + + r32 cos_theta = cosf(angle_radians); + r32 sin_theta = sinf(angle_radians); + r32 cos_value = 1.0f - cos_theta; + + res.data[0][0] = (axis.x * axis.x * cos_value) + cos_theta; + res.data[0][1] = (axis.x * axis.y * cos_value) + (axis.z * sin_theta); + res.data[0][2] = (axis.x * axis.z * cos_value) - (axis.y * sin_theta); + + res.data[1][0] = (axis.x * axis.y * cos_value) - (axis.z * sin_theta); + res.data[1][1] = (axis.y * axis.y * cos_value) + cos_theta; + res.data[1][2] = (axis.y * axis.z * cos_value) + (axis.x * sin_theta); + + res.data[2][0] = (axis.x * axis.z * cos_value) + (axis.y * sin_theta); + res.data[2][1] = (axis.z * axis.y * cos_value) - (axis.x * sin_theta); + res.data[2][2] = (axis.z * axis.z * cos_value) + cos_theta; + + return res; +} + +Mat4 perspective_projection_matrix4m(r32 left, r32 right, r32 bottom, r32 top, r32 near, r32 far) +{ + Mat4 res = { 0 }; + + res.data[0][0] = (2.0 * near)/(right - left); + res.data[0][2] = (right + left)/(right - left); + + res.data[1][1] = (2.0 * near)/(top - bottom); + res.data[1][2] = (top + bottom)/(top - bottom); + + res.data[2][2] = -(far + near)/(far - near); + res.data[2][3] = -2.0*far*near/(far - near); + + res.data[3][2] = -1.0; + + return res; +} + +Mat4 perspective4m(r32 fov, r32 aspect_ratio, r32 near, r32 far) +{ + r32 cotangent = 1.0f / tanf(fov / 2.0f); + + Mat4 res = { 0 }; + + res.data[0][0] = cotangent / aspect_ratio; + + res.data[1][1] = cotangent; + + res.data[2][2] = -(far + near) / (far - near); + res.data[2][3] = -2.0f * far * near / (far - near); + + res.data[3][2] = -1.0f; + + return res; +} + +Mat4 lookat4m(Vec3 up, Vec3 forward, Vec3 right, Vec3 position) +{ + /* + * @note: The construction of the lookat matrix is not obvious. For that reason here is the supplemental matrial I have used to understand + * things while I maintain my elementary understanding of linear algebra. + * 1. This youtube video (https://www.youtube.com/watch?v=3ZmqJb7J5wE) helped me understand why we invert matrices. + * It is because, we are moving from the position matrix which is a global to the view matrix which + * is a local. It won't be very clear from this illustration alone, so you would be best served watching the video and recollecting and understanding from there. + * 2. This article (https://twodee.org/blog/17560) derives (or rather shows), in a very shallow way how we get to the look at matrix. + */ + Mat4 res = init_value4m(1.0); + res.xyzw[0] = Vec4{ right.x, right.y, right.z, -dot_multiply3v(right, position) }; + res.xyzw[1] = Vec4{ up.x, up.y, up.z, -dot_multiply3v(up, position) }; + res.xyzw[2] = Vec4{ forward.x, forward.y, forward.z, -dot_multiply3v(forward, position) }; + res.xyzw[3] = Vec4{ 0.0f, 0.0f, 0.0f, 1.0f }; + + return res; +} + +Mat4 camera_create4m(Vec3 camera_pos, Vec3 camera_look, Vec3 camera_up) +{ + // @note: We do this because this allows the camera to have the axis it looks at + // inwards be the +z axis. + // If we did not do this, then the inward axis the camera looks at would be negative. + // I am still learning from learnopengl.com but I imagine that this was done for conveniences' sake. + Vec3 camera_forward_dir = normalize3v(subtract3v(camera_pos, camera_look)); + Vec3 camera_right_dir = normalize3v(cross_multiply3v(camera_up, camera_forward_dir)); + Vec3 camera_up_dir = normalize3v(cross_multiply3v(camera_forward_dir, camera_right_dir)); + + Mat4 res = lookat4m(camera_up_dir, camera_forward_dir, camera_right_dir, camera_pos); + + return res; +} + +Vec3 camera_look_around(r32 angle_pitch, r32 angle_yaw) +{ + Vec3 camera_look = {0.0}; + camera_look.x = cosf(angle_yaw) * cosf(angle_pitch); + camera_look.y = sinf(angle_pitch); + camera_look.z = sinf(angle_yaw) * cosf(angle_pitch); + camera_look = normalize3v(camera_look); + + return camera_look; +} + +int main(int argc, char* argv[]) +{ + int width = 1024; + int height = 768; + + if (SDL_Init(SDL_INIT_VIDEO) != 0) + { + printf("Error initialising SDL2: %s\n", SDL_GetError()); + return 0; + }; + + // set opengl version and profile + 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); + + // initialise window with opengl flag + SDL_Window* window = SDL_CreateWindow("SDL Test", + 50, + 50, + width, + height, + SDL_WINDOW_OPENGL); + + SDL_SetRelativeMouseMode(SDL_TRUE); + + // create an opengl context + SDL_GLContext context = SDL_GL_CreateContext(window); + if (!context) + { + printf("OpenGL context creation failed: %s\n", SDL_GetError()); + return -1; + } + + + // load glad + if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) { + printf("Failed to initialize Glad\n"); + return 1; + } + + // filesystem playground stuff + size_t read_count; + char* vertex_source = (char*)SDL_LoadFile("./source/shaders/light_subject.vs.glsl", &read_count); + char* fragment_source = (char*)SDL_LoadFile("./source/shaders/light_subject.fs.glsl", &read_count); + char* light_vertex_source = (char*)SDL_LoadFile("./source/shaders/light_source.vs.glsl", &read_count); + char* light_fragment_source = (char*)SDL_LoadFile("./source/shaders/light_source.fs.glsl", &read_count); + + GLuint vertex_shader = gl_create_vertex_shader(vertex_source); + GLuint fragment_shader = gl_create_fragment_shader(fragment_source); + GLuint shader_program = gl_create_shader_program(vertex_shader, fragment_shader); + GLuint light_vs = gl_create_vertex_shader(light_vertex_source); + GLuint light_fs = gl_create_fragment_shader(light_fragment_source); + GLuint light_sp = gl_create_shader_program(light_vs, light_fs); + printf("Successfully compiled shaders.\n"); + + r32 cube_normal_vertices[] = { + // positions // normals // texture coords + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f + }; + + r32 cube_vertices[] = { + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, + + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, + + -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, + -0.5f, 0.5f, -0.5f, 1.0f, 1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, + + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 1.0f, + + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f + }; + + GLuint light_VBO, light_VAO; + { + glGenVertexArrays(1, &light_VAO); + glGenBuffers(1, &light_VBO); + + glBindVertexArray(light_VAO); + + glBindBuffer(GL_ARRAY_BUFFER, light_VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0); + glEnableVertexAttribArray(0); + + glBindVertexArray(0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + } + + GLuint VBO, VAO, EBO, steel_wood_container, steel_wood_specular; + { + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + + glBindVertexArray(VAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(cube_normal_vertices), cube_normal_vertices, GL_STATIC_DRAW); + + // Position Attribute + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); + glEnableVertexAttribArray(0); + + // normal attribute + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); + glEnableVertexAttribArray(1); + + // Texture Attributes + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); + glEnableVertexAttribArray(2); + + int img_width, img_height, img_nrChannels; + + // ==== Texture 1 ==== + glGenTextures(1, &steel_wood_container); + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, steel_wood_container); + + const char* steel_wood_path = "assets/steel_wood_container.png"; + stbi_set_flip_vertically_on_load(1); + unsigned char* steel_wood_data = stbi_load(steel_wood_path, &img_width, &img_height, &img_nrChannels, 0); + + // Texture Properties + 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_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + + // Texture Data + if (steel_wood_data) + { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img_width, img_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, steel_wood_data); + glGenerateMipmap(GL_TEXTURE_2D); + } + else + { + printf("Error! Failed to load image from `%s`\n", steel_wood_path); + } + stbi_image_free(steel_wood_data); + + // ==== Texture 2 ==== + glGenTextures(1, &steel_wood_specular); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, steel_wood_specular); + const char* steel_wood_specular_path = "assets/steel_wood_specular.png"; + unsigned char* steel_wood_specular_data = stbi_load(steel_wood_specular_path, &img_width, &img_height, &img_nrChannels, 0); + + // Texture Properties + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + + // Texture Data + if (steel_wood_specular_data) + { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img_width, img_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, steel_wood_specular_data); + glGenerateMipmap(GL_TEXTURE_2D); + } + else + { + printf("Error! Failed to load image from `%s`\n", steel_wood_specular_path); + } + stbi_image_free(steel_wood_specular_data); + + glBindVertexArray(0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + //glBindTexture(GL_TEXTURE_2D, 0); + } + + glUseProgram(shader_program); + Vec3 ambient_color = Vec3{ 0.0f, 0.1f, 0.6f }; + Vec3 diffuse_color = Vec3{ 0.0f, 0.50980392f, 0.50980392f}; + Vec3 specular_color = Vec3{ 0.50196078f, 0.50196078f, 0.50196078f}; + Vec3 light_color = Vec3{ 1.0f, 1.0f, 1.0f}; + r32 specular_shine_factor = 128.0f * 0.25f; + + // material uniforms + int mat_diffuse_loc = glGetUniformLocation(shader_program, "material.diffuse"); + glUniform1i(mat_diffuse_loc, 0); + + int mat_specular_loc = glGetUniformLocation(shader_program, "material.specular"); + glUniform1i(mat_specular_loc, 1); + + int shine_factor_loc = glGetUniformLocation(shader_program, "material.shininess"); + glUniform1f(shine_factor_loc, specular_shine_factor); + + // directional light things + // - directional light params + Vec3 DL_direction = Vec3{ 0.0f, -1.0f, 0.0f }; + Vec3 DL_ambient = Vec3{ 0.2f, 0.2f, 0.2f }; + Vec3 DL_diffuse = Vec3{ 0.5f, 0.5f, 0.5f }; + Vec3 DL_specular = Vec3{ 1.0f, 1.0f, 1.0f }; + + int DL_ambient_loc = glGetUniformLocation(shader_program, "dirLight.ambient"); + int DL_diffuse_loc = glGetUniformLocation(shader_program, "dirLight.diffuse"); + int DL_specular_loc = glGetUniformLocation(shader_program, "dirLight.specular"); + int DL_dir_loc = glGetUniformLocation(shader_program, "dirLight.direction"); + + glUniform3fv(DL_dir_loc, 1, DL_direction.data); + glUniform3fv(DL_ambient_loc, 1, DL_ambient.data); + glUniform3fv(DL_diffuse_loc, 1, DL_diffuse.data); + glUniform3fv(DL_specular_loc, 1, DL_specular.data); + + // pointlight things + // - point light params + Vec3 MPL_position[4] = { + Vec3{ 0.0f, 0.0f, 5.0f }, + Vec3{ 0.0f, 0.0f, -8.0f }, + Vec3{ -5.0f, 0.0f, -5.0f }, + Vec3{ 5.0f, 0.0f, -5.0f }, + }; + Vec3 MPL_ambient[4] = { + Vec3{ 0.2f, 0.2f, 0.2f }, + Vec3{ 0.2f, 0.2f, 0.2f }, + Vec3{ 0.2f, 0.2f, 0.2f }, + Vec3{ 0.2f, 0.2f, 0.2f } + }; + Vec3 MPL_diffuse[4] = { + Vec3{ 0.5f, 0.5f, 0.5f }, + Vec3{ 0.5f, 0.5f, 0.5f }, + Vec3{ 0.5f, 0.5f, 0.5f }, + Vec3{ 0.5f, 0.5f, 0.5f } + }; + Vec3 MPL_specular[4] = { + Vec3{ 1.0f, 1.0f, 1.0f }, + Vec3{ 1.0f, 1.0f, 1.0f }, + Vec3{ 1.0f, 1.0f, 1.0f }, + Vec3{ 1.0f, 1.0f, 1.0f } + }; + + for (int i=0; i < 4; i++) + { + char buffer[64]; + sprintf(buffer, "multiPointLight[%i].ambient", i); + int MPL_ambient_loc = glGetUniformLocation(shader_program, buffer); + sprintf(buffer, "multiPointLight[%i].diffuse", i); + int MPL_diffuse_loc = glGetUniformLocation(shader_program, buffer); + sprintf(buffer, "multiPointLight[%i].specular", i); + int MPL_specular_loc = glGetUniformLocation(shader_program, buffer); + sprintf(buffer, "multiPointLight[%i].position", i); + int MPL_pos_loc = glGetUniformLocation(shader_program, buffer); + sprintf(buffer, "multiPointLight[%i].kC", i); + int MPL_kc_loc = glGetUniformLocation(shader_program, buffer); + sprintf(buffer, "multiPointLight[%i].kL", i); + int MPL_kl_loc = glGetUniformLocation(shader_program, buffer); + sprintf(buffer, "multiPointLight[%i].kQ", i); + int MPL_kq_loc = glGetUniformLocation(shader_program, buffer); + + glUniform3fv(MPL_pos_loc, 1, MPL_position[i].data); + glUniform3fv(MPL_ambient_loc, 1, MPL_ambient[i].data); + glUniform3fv(MPL_diffuse_loc, 1, MPL_diffuse[i].data); + glUniform3fv(MPL_specular_loc, 1, MPL_specular[i].data); + // attenuation factors + glUniform1f(MPL_kc_loc, 1.0f); + glUniform1f(MPL_kl_loc, 0.09f); + glUniform1f(MPL_kq_loc, 0.032f); + } + + + + // spotlight things + // - spot light params + Vec3 SL_ambient = Vec3{ 0.2f, 0.2f, 0.2f }; + Vec3 SL_diffuse = Vec3{ 0.5f, 0.5f, 0.5f }; + Vec3 SL_specular = Vec3{ 1.0f, 1.0f, 1.0f }; + + int SL_ambient_loc = glGetUniformLocation(shader_program, "spotLight.ambient"); + int SL_diffuse_loc = glGetUniformLocation(shader_program, "spotLight.diffuse"); + int SL_specular_loc = glGetUniformLocation(shader_program, "spotLight.specular"); + int SL_pos_loc = glGetUniformLocation(shader_program, "spotLight.position"); + int SL_kc_loc = glGetUniformLocation(shader_program, "spotLight.kC"); + int SL_kl_loc = glGetUniformLocation(shader_program, "spotLight.kL"); + int SL_kq_loc = glGetUniformLocation(shader_program, "spotLight.kQ"); + int SL_radius_inner = glGetUniformLocation(shader_program, "spotLight.radius_inner"); + int SL_radius_outer = glGetUniformLocation(shader_program, "spotLight.radius_outer"); + int SL_front_loc = glGetUniformLocation(shader_program, "spotLight.front"); + + glUniform3fv(SL_ambient_loc, 1, SL_ambient.data); + glUniform3fv(SL_diffuse_loc, 1, SL_diffuse.data); + glUniform3fv(SL_specular_loc, 1, SL_specular.data); + // attenuation factors + glUniform1f(SL_kc_loc, 1.0f); + glUniform1f(SL_kl_loc, 0.09f); + glUniform1f(SL_kq_loc, 0.032f); + // radius + glUniform1f(SL_radius_inner, cosf(To_Radian(10.0f))); + glUniform1f(SL_radius_outer, cosf(To_Radian(15.00f))); + // end spotlight things + + int light_uniform_loc = glGetUniformLocation(shader_program, "lightColor"); + glUniform3fv(light_uniform_loc, 1, light_color.data); + + + int camera_pos_loc = glGetUniformLocation(shader_program, "cameraPosition"); + + // objects + Vec3 model_translations[] = { + Vec3{ 0.0, 0.0, 0.0}, + Vec3{ -1.0, 0.0, -2.0}, + Vec3{ 2.0, 0.0, -5.0}, + Vec3{ -3.0, 5.0, -6.0}, + Vec3{ 3.0, -7.0, -6.0}, + }; + + r32 FOV = 90.0; + r32 time_curr; + r32 time_prev = SDL_GetTicks64() / 100.0; + uint32_t model_loc = glGetUniformLocation(shader_program, "Model"); + + // camera stuff + Vec3 camera_pos = Vec3{ 0.0, 5.0, 10.0f}; + Vec3 preset_up_dir = Vec3{ 0.0, 1.0, 0.0 }; + + r32 angle_yaw, angle_pitch, angle_roll; + angle_pitch = (r32)To_Radian(0.0f); + angle_yaw = (r32)-To_Radian(90.0f); + + Vec3 camera_look = camera_look_around(angle_pitch, angle_yaw); + + // @todo: remove this, I dont like this and think that this is unnecessary + Vec3 camera_look_increment; + r32 camera_speed = 0.5f; + + Mat4 view = camera_create4m(camera_pos, camera_look, preset_up_dir); + + uint32_t view_loc = glGetUniformLocation(shader_program, "View"); + glUniformMatrix4fv(view_loc, 1, GL_TRUE, view.buffer); + + Mat4 proj = perspective4m((r32)To_Radian(90.0), (r32)width / (r32)height, 0.1f, 100.0f); + uint32_t proj_loc = glGetUniformLocation(shader_program, "Projection"); + glUniformMatrix4fv(proj_loc, 1, GL_TRUE, proj.buffer); + + glUseProgram(light_sp); + uint32_t light_view_loc = glGetUniformLocation(light_sp, "View"); + glUniformMatrix4fv(light_view_loc, 1, GL_TRUE, view.buffer); + uint32_t light_proj_loc = glGetUniformLocation(light_sp, "Projection"); + glUniformMatrix4fv(light_proj_loc, 1, GL_TRUE, proj.buffer); + + glEnable(GL_DEPTH_TEST); + + u8 game_running = true; + + u8 hold_lshift = false; + u8 move_w = false; + u8 move_a = false; + u8 move_s = false; + u8 move_d = false; + + while(game_running) + { + + // frame delta + time_curr = SDL_GetTicks64() / 100.0; + r32 time_delta = time_curr - time_prev; + + r32 camera_speed_adjusted = time_delta * camera_speed; + camera_look_increment = scaler_multiply3v(camera_look, camera_speed_adjusted); + + SDL_Event ev; + while(SDL_PollEvent(&ev)) + { + + // INPUT + switch (ev.type) + { + case (SDL_QUIT): + { + game_running = false; + } break; + case (SDL_KEYDOWN): + { + if (ev.key.keysym.sym == SDLK_LSHIFT) + { + hold_lshift = true; + } + if (ev.key.keysym.sym == SDLK_SPACE) + {} + if (ev.key.keysym.sym == SDLK_UP) + { + { + specular_shine_factor = specular_shine_factor*2.0; + } + } + if (ev.key.keysym.sym == SDLK_DOWN) + { + { + specular_shine_factor = specular_shine_factor/2.0; + } + } + if (ev.key.keysym.sym == SDLK_w) + { + move_w = true; + } + if (ev.key.keysym.sym == SDLK_s) + { + move_s = true; + } + if (ev.key.keysym.sym == SDLK_a) + { + move_a = true; + } + if (ev.key.keysym.sym == SDLK_d) + { + move_d = true; + } + } break; + case (SDL_KEYUP): + { + if (ev.key.keysym.sym == SDLK_LSHIFT) + { + hold_lshift = false; + } + if (ev.key.keysym.sym == SDLK_w) + { + move_w = false; + } + if (ev.key.keysym.sym == SDLK_s) + { + move_s = false; + } + if (ev.key.keysym.sym == SDLK_a) + { + move_a = false; + } + if (ev.key.keysym.sym == SDLK_d) + { + move_d = false; + } + } break; + case (SDL_MOUSEMOTION): + { + SDL_MouseMotionEvent mouse_event = ev.motion; + r32 x_motion = (r32)mouse_event.xrel; + r32 y_motion = (r32)mouse_event.yrel; + if (x_motion != 0.0 || y_motion != 0.0) + { + angle_yaw = angle_yaw + To_Radian(x_motion * 0.1f); + angle_pitch = clampf(angle_pitch + To_Radian(-y_motion * 0.1f), To_Radian(-89.0f), To_Radian(89.0f)); + + camera_look = camera_look_around(angle_pitch, angle_yaw); + } + } break; + default: + { + break; + } + } + } + + // PROCESS + if (move_w) + { + camera_pos = add3v(camera_pos, camera_look_increment); + } + if (move_s) + { + camera_pos = subtract3v(camera_pos, camera_look_increment); + } + if (move_a) + { + Vec3 camera_right = normalize3v(cross_multiply3v(preset_up_dir, camera_look)); + Vec3 camera_right_scaled = scaler_multiply3v(camera_right, camera_speed_adjusted); + camera_pos = add3v(camera_pos, camera_right_scaled); + } + if (move_d) + { + Vec3 camera_right = normalize3v(cross_multiply3v(preset_up_dir, camera_look)); + Vec3 camera_right_scaled = scaler_multiply3v(camera_right, camera_speed_adjusted); + camera_pos = subtract3v(camera_pos, camera_right_scaled); + } + // light_location.z = 10.00 * sinf(time_curr/10.0); + view = camera_create4m(camera_pos, add3v(camera_pos, camera_look), preset_up_dir); + + // object shader program stuff + glUseProgram(shader_program); + + // Update spot light params + glUniform3fv(SL_pos_loc, 1, camera_pos.data); + glUniform3fv(SL_front_loc, 1, camera_look.data); + + glUniformMatrix4fv(view_loc, 1, GL_TRUE, view.buffer); + glUniform3fv(camera_pos_loc, 1, camera_pos.data); + + // light/lamp shader program stuff + //glUseProgram(light_sp); + //glUniformMatrix4fv(light_view_loc, 1, GL_TRUE, view.buffer); + + time_prev = time_curr; + + + // OUTPUT + //glClearColor(1.0f, 0.6f, .6f, 1.0f); + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + //glActiveTexture(GL_TEXTURE1); + //glBindTexture(GL_TEXTURE_2D, container_texture); + + glUseProgram(light_sp); + glBindVertexArray(light_VAO); + for (int i = 0; i < 4; i++) + { + Mat4 light_model = translation_matrix4m(MPL_position[i].x, MPL_position[i].y, MPL_position[i].z); + uint32_t light_model_loc = glGetUniformLocation(light_sp, "Model"); + glUniformMatrix4fv(light_model_loc, 1, GL_TRUE, light_model.buffer); + + glUniformMatrix4fv(light_view_loc, 1, GL_TRUE, view.buffer); + glDrawArrays(GL_TRIANGLES, 0, 36); + } + glBindVertexArray(0); + glUseProgram(0); + + glUseProgram(shader_program); + glBindVertexArray(VAO); + + for (int i = 0; i < 5; i++) + { + Vec3 translation_iter = model_translations[i]; + Mat4 model = init_value4m(1.0); + Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z); + model = multiply4m(model_translation, model); + glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer); + glDrawArrays(GL_TRIANGLES, 0, 36); + } + + glBindVertexArray(0); + + + SDL_GL_SwapWindow(window); + } + + // opengl free calls + glDeleteVertexArrays(1, &VAO); + glDeleteBuffers(1, &VBO); + glDeleteProgram(shader_program); + + // sdl free calls + SDL_GL_DeleteContext(context); + SDL_DestroyWindow(window); + SDL_Quit(); + return 0; +} diff --git a/source/lessons/lighting/shaders/light_source.fs.glsl b/source/lessons/lighting/shaders/light_source.fs.glsl new file mode 100644 index 0000000..9e834cb --- /dev/null +++ b/source/lessons/lighting/shaders/light_source.fs.glsl @@ -0,0 +1,5 @@ +#version 330 core +out vec4 FragColor; +void main() { + FragColor = vec4(1.0); +} diff --git a/source/lessons/lighting/shaders/light_source.vs.glsl b/source/lessons/lighting/shaders/light_source.vs.glsl new file mode 100644 index 0000000..bf372d5 --- /dev/null +++ b/source/lessons/lighting/shaders/light_source.vs.glsl @@ -0,0 +1,10 @@ +#version 330 core +layout(location = 0) in vec3 position; + +uniform mat4 Model; +uniform mat4 View; +uniform mat4 Projection; + +void main() { + gl_Position = Projection * View * Model * vec4(position.x, position.y, position.z, 1.0); +} diff --git a/source/lessons/lighting/shaders/light_subject.fs.glsl b/source/lessons/lighting/shaders/light_subject.fs.glsl new file mode 100644 index 0000000..f3e1d58 --- /dev/null +++ b/source/lessons/lighting/shaders/light_subject.fs.glsl @@ -0,0 +1,200 @@ +#version 330 core + +/* +@note: an explanation of why the light direction vector is taken from fragment to the +light source. +Basic LA really, we need to calculate the angle between the direction of the 2 vectors: + a. The direction at which light incidents with the fragment + b. The normal vector +The reason the light direction is taken from the fragment to the light source, is precisely so we can calculate +the angle between the normal and the direction at which light would hit. This if taken as starting from the light +source would actually be incorrect, since we would be calculating the angle between the light source in the direction +of the fragment and the normal. Consider what happens when it is directly above. The angle becomes 180, not 0. This +is because the normal moves in the direction opposite to the lights direction if taken this way, which is not what +we expect or want. +Reversing this, allows us to consider the angle at the point in which light hits the fragment, and the normal vector +of the fragment. +*/ + +struct Material { + sampler2D diffuse; + sampler2D specular; + float shininess; +}; + +struct Light { + vec3 ambient; + vec3 diffuse; + vec3 specular; + + vec3 position; +}; + +struct DirectionalLight { + vec3 direction; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct PointLight { + vec3 position; + + vec3 ambient; + vec3 diffuse; + vec3 specular; + + // attentuation factors + float kC; + float kL; + float kQ; +}; + +struct SpotLight { + vec3 position; + + vec3 ambient; + vec3 diffuse; + vec3 specular; + + // attenuation factors + float kC; + float kL; + float kQ; + + // vector for the direction directly in front of the spotlight + vec3 front; + + // spot radius + float radius_inner; + float radius_outer; // to smooth out the light + +}; + +// this is the result of a light creation. This contains the multipliers for each kind of a light we want +// to have. +struct LightFactor { + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +in vec2 texCoords; +in vec3 fragNormal; +in vec3 worldPosition; + +uniform Material material; + +uniform Light light; +uniform DirectionalLight dirLight; +uniform PointLight pointLight; +uniform PointLight multiPointLight[4]; +uniform SpotLight spotLight; + +uniform vec3 cameraPosition; +uniform vec3 lightColor; + +out vec4 FragColor; + +LightFactor make_directional_light(DirectionalLight light, vec3 CONST_viewDir) { + LightFactor res; + + vec3 DL_lightDir = normalize(-light.direction); + res.ambient = light.ambient; + + float DL_diffuseStrength = max(dot(DL_lightDir, fragNormal), 0.0); + res.diffuse = light.diffuse * DL_diffuseStrength; + + vec3 DL_reflectDir = reflect(-DL_lightDir, fragNormal); + float DL_specularity = max(dot(CONST_viewDir, DL_reflectDir), 0.0); + float DL_shinePower = pow(DL_specularity, material.shininess); + res.specular = light.specular * DL_shinePower; + + return res; +}; + +LightFactor make_point_light(PointLight light, vec3 CONST_viewDir) { + LightFactor res; + + float PL_lightDistance = length(light.position - worldPosition); + float PL_attenuationFactor = 1.0 / + (light.kC + (light.kL * PL_lightDistance) + (light.kQ * PL_lightDistance * PL_lightDistance)); + res.ambient = PL_attenuationFactor * light.ambient; + + vec3 PL_lightDir = normalize(light.position - worldPosition); + float PL_diffuseStrength = max(dot(PL_lightDir, fragNormal), 0.0); + res.diffuse = PL_attenuationFactor * light.diffuse * PL_diffuseStrength; + + vec3 PL_reflectDir = reflect(-PL_lightDir, fragNormal); + float PL_specularity = max(dot(CONST_viewDir, PL_reflectDir), 0.0); + float PL_shinePower = pow(PL_specularity, material.shininess); + res.specular = PL_attenuationFactor * PL_shinePower * light.specular; + + return res; +} + +LightFactor make_spot_light(SpotLight light, vec3 CONST_viewDir) { + LightFactor res; + + float SL_lightDistance = length(light.position - worldPosition); + float SL_attenuationFactor = 1.0 / + (light.kC + (light.kL * SL_lightDistance) + (light.kQ * SL_lightDistance * SL_lightDistance)); + vec3 SL_lightDir = normalize(light.position - worldPosition); + + res.ambient = SL_attenuationFactor * light.ambient; + + float SL_diffAmount = dot(SL_lightDir, normalize(-light.front)); + float SL_spotLightFadeFactor = clamp((SL_diffAmount - light.radius_outer)/(light.radius_inner - light.radius_outer), 0.0f, 1.0f); + float SL_diffuseStrength = max(dot(SL_lightDir, fragNormal), 0.0); + res.diffuse = SL_spotLightFadeFactor * SL_attenuationFactor * light.diffuse * SL_diffuseStrength; + + vec3 SL_reflectDir = reflect(-SL_lightDir, fragNormal); + float SL_specularity = max(dot(CONST_viewDir, SL_reflectDir), 0.0); + float SL_shinePower = pow(SL_specularity, material.shininess); + res.specular = SL_spotLightFadeFactor * SL_attenuationFactor * SL_shinePower * light.specular; + + return res; +} + +void main() { + vec3 CONST_viewDir = normalize(cameraPosition - worldPosition); + vec3 combinedAmbience = vec3(0.0); + vec3 combinedDiffuse = vec3(0.0); + vec3 combinedSpecular = vec3(0.0); + + // directional light calculations and stuff + //LightFactor DL_factors = make_directional_light(dirLight, CONST_viewDir); + //combinedAmbience += DL_factors.ambient; + //combinedDiffuse += DL_factors.diffuse; + //combinedSpecular += DL_factors.specular; + + // pointlight calculations and stuff + //LightFactor PL_factors = make_point_light(pointLight, CONST_viewDir); + //combinedAmbience += PL_factors.ambient; + //combinedDiffuse += PL_factors.diffuse; + //combinedSpecular += PL_factors.specular; + + // multiple point lights + for (int i=0; i<4; i++) + { + PointLight pl = multiPointLight[i]; + LightFactor MPL_factors = make_point_light(pl, CONST_viewDir); + combinedAmbience += MPL_factors.ambient; + combinedDiffuse += MPL_factors.diffuse; + combinedSpecular += MPL_factors.specular; + } + + // spotlight calculations + LightFactor SL_factors = make_spot_light(spotLight, CONST_viewDir); + combinedAmbience += SL_factors.ambient; + combinedDiffuse += SL_factors.diffuse; + combinedSpecular += SL_factors.specular; + + vec3 ambientLight = combinedAmbience * vec3(texture(material.diffuse, texCoords)); + vec3 diffuseLight = combinedDiffuse * vec3(texture(material.diffuse, texCoords)); + vec3 specularLight = combinedSpecular * vec3(texture(material.specular, texCoords)); + + vec3 color = ambientLight + diffuseLight + specularLight; + FragColor = vec4(color, 1.0); +} diff --git a/source/lessons/lighting/shaders/light_subject.vs.glsl b/source/lessons/lighting/shaders/light_subject.vs.glsl new file mode 100644 index 0000000..49e58d8 --- /dev/null +++ b/source/lessons/lighting/shaders/light_subject.vs.glsl @@ -0,0 +1,21 @@ +#version 330 core + +layout(location = 0) in vec3 position; +layout(location = 1) in vec3 normal; +layout(location = 2) in vec2 inTexCoords; + +uniform mat4 Model; +uniform mat4 View; +uniform mat4 Projection; + +out vec3 fragNormal; +out vec3 worldPosition; +out vec2 texCoords; + +void main() { + gl_Position = Projection * View * Model * vec4(position, 1.0); + worldPosition = vec3(Model * vec4(position, 1.0)); + fragNormal = mat3(transpose(inverse(Model))) * normal; + fragNormal = normalize(normal); + texCoords = inTexCoords; +} diff --git a/source/lessons/models/main.cpp b/source/lessons/models/main.cpp new file mode 100644 index 0000000..18a816b --- /dev/null +++ b/source/lessons/models/main.cpp @@ -0,0 +1,710 @@ +#include <stdio.h> +#include <SDL2/SDL.h> +#include <glad/glad.h> +#include <assimp/Importer.hpp> +#include <assimp/scene.h> +#include <assimp/postprocess.h> +#include <vector> + +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" + +/* @lookup: +* - I do not understand how floating point numbers work, so I should probably look into that. +* - The normal matrix calculation in the fragment shader for the object affected by light has been mainly copied. +* I have tried to understand the formula, and whilst it made some sense, it is not fully clear to me, and I cannot picture it yet. +* Revisit the derivation for the normal matrix some time in the future. +* - Lookup the derivation of the formula for reflecting a vector about a normal. I am doing that for specular lighting, but the learnopengl tutorial +* just uses a glsl reflect formula, and at the time of writing it is also very late so I am not in the mood or position to look into it at present. +* - One of the things I have observed with specular lights is that the circle/specular highlight follows the camera (me) when I move. I would like to figure +* out a way by which this does not happen and it remains fixed on the object, at the angle at which it hits. All of this will be made complicated by the fact +* that ofcourse everything is actually happening from the cameras' perspective. I would still love to figure this out. +*/ + +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; + +typedef int8_t s8; +typedef int16_t s16; +typedef int32_t s32; +typedef int64_t s64; + +typedef float r32; +typedef double r64; + +typedef u8 b8; + + +#include "math.h" + +// =========== Shader Loading ============= + +unsigned int gl_create_vertex_shader(char* vertex_shader_source) +{ + unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL); + glCompileShader(vertex_shader); + + int success; + char info_log[512]; + glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success); + if (!success) + { + glGetShaderInfoLog(vertex_shader, 512, NULL, info_log); + printf("================================\n"); + printf("vertex shader compilation failed:\n%s\n", info_log); + } + + return vertex_shader; +} + +unsigned int gl_create_fragment_shader(char* fragment_shader_source) +{ + unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL); + glCompileShader(fragment_shader); + + int success; + char info_log[512]; + glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success); + if (!success) + { + glGetShaderInfoLog(fragment_shader, 512, NULL, info_log); + printf("================================\n"); + printf("fragment shader compilation failed:\n%s\n", info_log); + } + + return fragment_shader; +} + +unsigned int gl_create_shader_program(unsigned int vertex_shader, unsigned int fragment_shader) +{ + unsigned int shader_program = glCreateProgram(); + + glAttachShader(shader_program, vertex_shader); + glAttachShader(shader_program, fragment_shader); + glLinkProgram(shader_program); + + int success; + char info_log[512]; + glGetProgramiv(shader_program, GL_LINK_STATUS, &success); + if (!success) + { + glGetProgramInfoLog(shader_program, 512, NULL, info_log); + printf("================================\n"); + printf("shader program linking failed:\n%s\n", info_log); + } + + glDeleteShader(vertex_shader); + glDeleteShader(fragment_shader); + + return shader_program; +} + +Mat4 camera_create4m(Vec3 camera_pos, Vec3 camera_look, Vec3 camera_up) +{ + // @note: We do this because this allows the camera to have the axis it looks at + // inwards be the +z axis. + // If we did not do this, then the inward axis the camera looks at would be negative. + // I am still learning from learnopengl.com but I imagine that this was done for conveniences' sake. + Vec3 camera_forward_dir = normalize3v(subtract3v(camera_pos, camera_look)); + Vec3 camera_right_dir = normalize3v(cross_multiply3v(camera_up, camera_forward_dir)); + Vec3 camera_up_dir = normalize3v(cross_multiply3v(camera_forward_dir, camera_right_dir)); + + Mat4 res = lookat4m(camera_up_dir, camera_forward_dir, camera_right_dir, camera_pos); + + return res; +} + +Vec3 camera_look_around(r32 angle_pitch, r32 angle_yaw) +{ + Vec3 camera_look = {0.0}; + camera_look.x = cosf(angle_yaw) * cosf(angle_pitch); + camera_look.y = sinf(angle_pitch); + camera_look.z = sinf(angle_yaw) * cosf(angle_pitch); + camera_look = normalize3v(camera_look); + + return camera_look; +} + +// =================== Model Loading ======================== +// This section contains a whole host of things: +// 1. classes +// 2. std::vectors +// 3. std::strings +// that I have only used as a glue for I did not know if I had the model loading setup properly. +// @todo: replace these things eventually. For now the goal is to complete learnopengl + +s32 TextureFromFile(const char* filepath, std::string directory) +{ + std::string filename = std::string(filepath); + filename = directory + '/' + filename; + + u32 texid; + glGenTextures(1, &texid); + + s32 width, height, nrChannels; + unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrChannels, 0); + if (data) + { + GLenum format; + if (nrChannels == 1) + format = GL_RED; + else if (nrChannels == 3) + format = GL_RGB; + else if (nrChannels == 4) + format = GL_RGBA; + + glBindTexture(GL_TEXTURE_2D, texid); + glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + 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); + + stbi_image_free(data); + } + else + { + printf("failed to load image texture at path: %s", filepath); + stbi_image_free(data); + } + + return texid; +} + +enum TextureType { TextureDiffuse=0, TextureSpecular }; + +struct Vertex { + Vec3 position; + Vec3 normal; + Vec2 texture; +}; + +struct Texture { + u32 id; + enum TextureType type; + std::string fname; +}; + +class Mesh { + public: + std::vector<Vertex> vertices; + std::vector<u32> indices; + std::vector<Texture> textures; + + u32 vao; + u32 vbo; + u32 ebo; + + Mesh(std::vector<Vertex> vertices, std::vector<u32> indices, std::vector<Texture> textures) + { + this->vertices = vertices; + this->indices = indices; + this->textures = textures; + + // setup mesh shader stuff + glGenVertexArrays(1, &vao); + glGenBuffers(1, &vbo); + glGenBuffers(1, &ebo); + + glBindVertexArray(vao); + + glBindBuffer(GL_ARRAY_BUFFER, vbo); + glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(struct Vertex), &(this->vertices[0]), GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->indices.size() * sizeof(u32), &(this->indices[0]), GL_STATIC_DRAW); + + // position + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0); + // normal + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, normal)); + // texture + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texture)); + + glBindVertexArray(0); + } + + void draw(u32 shader_program) + { + glUseProgram(shader_program); + + u32 diffuse_num = 1; + u32 specular_num = 1; + char tex_unit_name[64]; + // set shininess + s32 mat_shine_loc = glGetUniformLocation(shader_program, "material.shininess"); + glUniform1f(mat_shine_loc, 32.0f); + + for (u32 i=0; i<textures.size(); i++) + { + struct Texture curr_tex = textures[i]; + if (curr_tex.type == TextureDiffuse) + { + sprintf(tex_unit_name, "material.diffuse[%i]", diffuse_num); + } + else if (curr_tex.type == TextureSpecular) + { + sprintf(tex_unit_name, "material.diffuse[%i]", specular_num); + } + + glActiveTexture(GL_TEXTURE0 + i); + s32 tex_unit_loc = glGetUniformLocation(shader_program, tex_unit_name); + glUniform1i(tex_unit_loc, i); + glBindTexture(GL_TEXTURE_2D, curr_tex.id); + } + glActiveTexture(GL_TEXTURE0); + + glBindVertexArray(vao); + glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + } +}; + +class Model +{ + public: + Model(std::string path) + { + load_model(path); + } + void draw(u32 shader_program); + private: + std::vector<Texture> loaded_textures; + std::vector<Mesh> meshes; + std::string directory; + + void load_model(std::string path); + void process_node(aiNode *node, const aiScene *scene); + Mesh process_mesh(aiMesh *mesh, const aiScene *scene); + std::vector<Texture> load_material_textures(aiMaterial *mat, aiTextureType type, TextureType type_name); +}; + +void Model::draw(u32 shader_program) +{ + for (int i=0; i < meshes.size(); i++) + { + meshes[i].draw(shader_program); + } +} + +void Model::load_model(std::string path) +{ + Assimp::Importer import; + const aiScene *scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs); + + if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) + { + printf("error loading model :%s\n", import.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 (int i=0; i < node->mNumMeshes; i++) + { + aiMesh *mesh = scene->mMeshes[node->mMeshes[i]]; + meshes.push_back(process_mesh(mesh, scene)); + } + + for (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<u32> indices; + std::vector<Texture> textures; + + for (u32 i=0; i < mesh->mNumVertices; i++) + { + Vec3 position; + position.x = mesh->mVertices[i].x; + position.y = mesh->mVertices[i].y; + position.z = mesh->mVertices[i].z; + + Vec3 normal; + normal.x = mesh->mNormals[i].x; + normal.y = mesh->mNormals[i].y; + normal.z = mesh->mNormals[i].z; + + Vec2 texture = {0, 0}; + if (mesh->mTextureCoords[0]) + { + texture.x = mesh->mTextureCoords[0][i].x; + texture.y = mesh->mTextureCoords[0][i].y; + } + + struct Vertex vertex; + vertex.position = position; + vertex.normal = normal; + vertex.texture = texture; + + vertices.push_back(vertex); + } + // process indices + for (u32 i = 0; i < mesh->mNumFaces; i++) + { + aiFace face = mesh->mFaces[i]; + for(u32 j = 0; j < face.mNumIndices; j++) + { + indices.push_back(face.mIndices[j]); + } + } + // process material + if (mesh->mMaterialIndex >= 0) + { + aiMaterial *material = scene->mMaterials[mesh->mMaterialIndex]; + std::vector<Texture> diffuse_maps = load_material_textures(material, aiTextureType_DIFFUSE, TextureDiffuse); + textures.insert(textures.end(), diffuse_maps.begin(), diffuse_maps.end()); + std::vector<Texture> specular_maps = load_material_textures(material, aiTextureType_SPECULAR, TextureSpecular); + textures.insert(textures.end(), specular_maps.begin(), specular_maps.end()); + } + + return Mesh(vertices, indices, textures); +} + +std::vector<Texture> Model::load_material_textures(aiMaterial *mat, aiTextureType type, TextureType tex_type) +{ + std::vector<Texture> textures; + for(u32 i=0; i<mat->GetTextureCount(type); i++) + { + bool load_texture = true; + aiString str; + mat->GetTexture(type, i, &str); + const char* fname = str.C_Str(); + + for (s32 j=0; j<loaded_textures.size(); j++) + { + if (std::strcmp(loaded_textures[j].fname.data(), fname) == 0) + { + load_texture = false; + textures.push_back(loaded_textures[j]); + break; + } + } + if (load_texture) + { + Texture texture; + texture.id = TextureFromFile(fname, directory); + texture.type = tex_type; + texture.fname = std::string(fname); + textures.push_back(texture); + loaded_textures.push_back(texture); + } + } + + return textures; +} + +int main(int argc, char* argv[]) +{ + + // ============ END ============ + int width = 1024; + int height = 768; + + if (SDL_Init(SDL_INIT_VIDEO) != 0) + { + printf("Error initialising SDL2: %s\n", SDL_GetError()); + return 0; + }; + + // set opengl version and profile + 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); + + // initialise window with opengl flag + SDL_Window* window = SDL_CreateWindow("SDL Test", + 50, + 50, + width, + height, + SDL_WINDOW_OPENGL); + + SDL_SetRelativeMouseMode(SDL_TRUE); + + // create an opengl context + SDL_GLContext context = SDL_GL_CreateContext(window); + if (!context) + { + printf("OpenGL context creation failed: %s\n", SDL_GetError()); + return -1; + } + + + // load glad + if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) { + printf("Failed to initialize Glad\n"); + return 1; + } + + // filesystem playground stuff + size_t read_count; + char* vertex_source = (char*)SDL_LoadFile("./source/shaders/model/model.vs.glsl", &read_count); + char* fragment_source = (char*)SDL_LoadFile("./source/shaders/model/model.fs.glsl", &read_count); + + GLuint vertex_shader = gl_create_vertex_shader(vertex_source); + GLuint fragment_shader = gl_create_fragment_shader(fragment_source); + GLuint shader_program = gl_create_shader_program(vertex_shader, fragment_shader); + printf("Successfully compiled shaders.\n"); + + glUseProgram(shader_program); + + stbi_set_flip_vertically_on_load(1); + // ============ Start Model handling using Assimp ============ + // loading a 3d model using assimp + Model test_model = Model(std::string("assets/Survival_Backpack/backpack.obj")); + + // directional light things + // - directional light params + Vec3 DL_direction = Vec3{ 0.0f, -0.5f, -1.0f }; + Vec3 DL_ambient = Vec3{ 0.2f, 0.2f, 0.2f }; + Vec3 DL_diffuse = Vec3{ 0.5f, 0.5f, 0.5f }; + Vec3 DL_specular = Vec3{ 1.0f, 1.0f, 1.0f }; + + int DL_ambient_loc = glGetUniformLocation(shader_program, "dirLight.ambient"); + int DL_diffuse_loc = glGetUniformLocation(shader_program, "dirLight.diffuse"); + int DL_specular_loc = glGetUniformLocation(shader_program, "dirLight.specular"); + int DL_dir_loc = glGetUniformLocation(shader_program, "dirLight.direction"); + + glUniform3fv(DL_dir_loc, 1, DL_direction.data); + glUniform3fv(DL_ambient_loc, 1, DL_ambient.data); + glUniform3fv(DL_diffuse_loc, 1, DL_diffuse.data); + glUniform3fv(DL_specular_loc, 1, DL_specular.data); + + // load point light + Vec3 PL_position = Vec3{ 0.0f, 0.0f, 3.0f }; + Vec3 PL_ambient = Vec3{ 0.2f, 0.2f, 0.2f }; + Vec3 PL_diffuse = Vec3{ 0.5f, 0.5f, 0.5f }; + Vec3 PL_specular = Vec3{ 1.0f, 1.0f, 1.0f }; + + s32 PL_pos_loc = glGetUniformLocation(shader_program, "pointLight.position"); + s32 PL_ambient_loc = glGetUniformLocation(shader_program, "pointLight.ambient"); + s32 PL_diffuse_loc = glGetUniformLocation(shader_program, "pointLight.diffuse"); + s32 PL_specular_loc = glGetUniformLocation(shader_program, "pointLight.specular"); + s32 PL_kc_loc = glGetUniformLocation(shader_program, "pointLight.kC"); + s32 PL_kl_loc = glGetUniformLocation(shader_program, "pointLight.kL"); + s32 PL_kq_loc = glGetUniformLocation(shader_program, "pointLight.kQ"); + + glUniform3fv(PL_pos_loc, 1, PL_position.data); + glUniform3fv(PL_ambient_loc, 1, PL_ambient.data); + glUniform3fv(PL_diffuse_loc, 1, PL_diffuse.data); + glUniform3fv(PL_specular_loc, 1, PL_specular.data); + // attenuation factors + glUniform1f(PL_kc_loc, 1.0f); + glUniform1f(PL_kl_loc, 0.09f); + glUniform1f(PL_kq_loc, 0.032f); + + int camera_pos_loc = glGetUniformLocation(shader_program, "cameraPosition"); + + // objects + Vec3 model_translations[] = { + Vec3{ 0.0, 0.0, 0.0}, + Vec3{ -1.0, 0.0, -2.0}, + Vec3{ 2.0, 0.0, -5.0}, + Vec3{ -3.0, 5.0, -6.0}, + Vec3{ 3.0, -7.0, -6.0}, + }; + + r32 FOV = 90.0; + r32 time_curr; + r32 time_prev = SDL_GetTicks64() / 100.0; + uint32_t model_loc = glGetUniformLocation(shader_program, "Model"); + + // camera stuff + Vec3 camera_pos = Vec3{ 0.0, 5.0, 10.0f}; + Vec3 preset_up_dir = Vec3{ 0.0, 1.0, 0.0 }; + + r32 angle_yaw, angle_pitch, angle_roll; + angle_pitch = (r32)To_Radian(0.0f); + angle_yaw = (r32)-To_Radian(90.0f); + + Vec3 camera_look = camera_look_around(angle_pitch, angle_yaw); + + // @todo: remove this, I dont like this and think that this is unnecessary + Vec3 camera_look_increment; + r32 camera_speed = 0.5f; + + Mat4 view = camera_create4m(camera_pos, camera_look, preset_up_dir); + + uint32_t view_loc = glGetUniformLocation(shader_program, "View"); + glUniformMatrix4fv(view_loc, 1, GL_TRUE, view.buffer); + + Mat4 proj = perspective4m((r32)To_Radian(90.0), (r32)width / (r32)height, 0.1f, 100.0f); + uint32_t proj_loc = glGetUniformLocation(shader_program, "Projection"); + glUniformMatrix4fv(proj_loc, 1, GL_TRUE, proj.buffer); + + glEnable(GL_DEPTH_TEST); + + u8 game_running = true; + + u8 hold_lshift = false; + u8 move_w = false; + u8 move_a = false; + u8 move_s = false; + u8 move_d = false; + + while(game_running) + { + + // frame delta + time_curr = SDL_GetTicks64() / 100.0; + r32 time_delta = time_curr - time_prev; + + r32 camera_speed_adjusted = time_delta * camera_speed; + camera_look_increment = scaler_multiply3v(camera_look, camera_speed_adjusted); + + SDL_Event ev; + while(SDL_PollEvent(&ev)) + { + + // INPUT + switch (ev.type) + { + case (SDL_QUIT): + { + game_running = false; + } break; + case (SDL_KEYDOWN): + { + if (ev.key.keysym.sym == SDLK_LSHIFT) + { + hold_lshift = true; + } + if (ev.key.keysym.sym == SDLK_w) + { + move_w = true; + } + if (ev.key.keysym.sym == SDLK_s) + { + move_s = true; + } + if (ev.key.keysym.sym == SDLK_a) + { + move_a = true; + } + if (ev.key.keysym.sym == SDLK_d) + { + move_d = true; + } + } break; + case (SDL_KEYUP): + { + if (ev.key.keysym.sym == SDLK_LSHIFT) + { + hold_lshift = false; + } + if (ev.key.keysym.sym == SDLK_w) + { + move_w = false; + } + if (ev.key.keysym.sym == SDLK_s) + { + move_s = false; + } + if (ev.key.keysym.sym == SDLK_a) + { + move_a = false; + } + if (ev.key.keysym.sym == SDLK_d) + { + move_d = false; + } + } break; + case (SDL_MOUSEMOTION): + { + SDL_MouseMotionEvent mouse_event = ev.motion; + r32 x_motion = (r32)mouse_event.xrel; + r32 y_motion = (r32)mouse_event.yrel; + if (x_motion != 0.0 || y_motion != 0.0) + { + angle_yaw = angle_yaw + To_Radian(x_motion * 0.1f); + angle_pitch = clampf(angle_pitch + To_Radian(-y_motion * 0.1f), To_Radian(-89.0f), To_Radian(89.0f)); + + camera_look = camera_look_around(angle_pitch, angle_yaw); + } + } break; + default: + { + break; + } + } + } + + // PROCESS + if (move_w) + { + camera_pos = add3v(camera_pos, camera_look_increment); + } + if (move_s) + { + camera_pos = subtract3v(camera_pos, camera_look_increment); + } + if (move_a) + { + Vec3 camera_right = normalize3v(cross_multiply3v(preset_up_dir, camera_look)); + Vec3 camera_right_scaled = scaler_multiply3v(camera_right, camera_speed_adjusted); + camera_pos = add3v(camera_pos, camera_right_scaled); + } + if (move_d) + { + Vec3 camera_right = normalize3v(cross_multiply3v(preset_up_dir, camera_look)); + Vec3 camera_right_scaled = scaler_multiply3v(camera_right, camera_speed_adjusted); + camera_pos = subtract3v(camera_pos, camera_right_scaled); + } + view = camera_create4m(camera_pos, add3v(camera_pos, camera_look), preset_up_dir); + + // object shader program stuff + glUseProgram(shader_program); + + glUniformMatrix4fv(view_loc, 1, GL_TRUE, view.buffer); + glUniform3fv(camera_pos_loc, 1, camera_pos.data); + + time_prev = time_curr; + + // OUTPUT + glClearColor(1.0f, 0.6f, .6f, 1.0f); + //glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + for (int i = 0; i < 1; i++) + { + Vec3 translation_iter = model_translations[i]; + Mat4 model = init_value4m(1.0); + Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z); + model = multiply4m(model_translation, model); + glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer); + test_model.draw(shader_program); + } + + SDL_GL_SwapWindow(window); + } + + // opengl free calls + //glDeleteVertexArrays(1, &VAO); + //glDeleteBuffers(1, &VBO); + glDeleteProgram(shader_program); + + // sdl free calls + SDL_GL_DeleteContext(context); + SDL_DestroyWindow(window); + SDL_Quit(); + return 0; +} diff --git a/source/lessons/models/math.h b/source/lessons/models/math.h new file mode 100644 index 0000000..77a650d --- /dev/null +++ b/source/lessons/models/math.h @@ -0,0 +1,394 @@ +#ifndef MATH_H +#define MATH_H + +#define PI 3.14159265358979323846264338327950288f +#define Square(x) ((x)*(x)) +#define To_Radian(x) ((x) * PI / 180.0f) +#define To_Degree(x) ((x) * 180.0f / PI) + +r32 clampf(r32 x, r32 bottom, r32 top) +{ + if (x < bottom) + { + x = bottom; + } + else if (x > top) + { + x = top; + } + + return x; +} + +// ==== Vector Math ==== + +union Vec2 { + struct { + r32 x; + r32 y; + }; + r32 data[2]; +}; + +union Vec3 { + struct { + r32 x; + r32 y; + r32 z; + }; + r32 data[3]; +}; + +union Vec4 { + struct { + r32 x; + r32 y; + r32 z; + r32 w; + }; + r32 data[4]; +}; + +union Mat4 { + Vec4 xyzw[4]; + r32 data[4][4]; + r32 buffer[16]; +}; + +// ========================================================== Vec3 ========================================================== + +Vec3 init3v(r32 x, r32 y, r32 z) +{ + Vec3 res; + res.x = x; + res.y = y; + res.z = z; + + return res; +} + +Vec3 scaler_add3v(Vec3 vec, r32 scaler) +{ + Vec3 res; + res.x = vec.x + scaler; + res.y = vec.y + scaler; + res.z = vec.z + scaler; + + return res; +} + +Vec3 scaler_multiply3v(Vec3 vec, r32 scaler) +{ + Vec3 res; + res.x = vec.x * scaler; + res.y = vec.y * scaler; + res.z = vec.z * scaler; + + return res; +} + +Vec3 scaler_divide3v(Vec3 vec, r32 scaler) +{ + Vec3 res; + res.x = vec.x / scaler; + res.y = vec.y / scaler; + res.z = vec.z / scaler; + + return res; +} + + +Vec3 add3v(Vec3 a, Vec3 b) +{ + Vec3 res; + res.x = a.x + b.x; + res.y = a.y + b.y; + res.z = a.z + b.z; + + return res; +} + +Vec3 subtract3v(Vec3 a, Vec3 b) +{ + Vec3 res; + res.x = a.x - b.x; + res.y = a.y - b.y; + res.z = a.z - b.z; + + return res; +} + +r32 dot_multiply3v(Vec3 a, Vec3 b) +{ + r32 x = a.x * b.x; + r32 y = a.y * b.y; + r32 z = a.z * b.z; + + r32 res = x + y + z; + + return res; +} + +r32 magnitude3v(Vec3 vec) +{ + r32 res = sqrtf(Square(vec.x) + Square(vec.y) + Square(vec.z)); + return res; +} + +Vec3 normalize3v(Vec3 vec) +{ + r32 magnitude = magnitude3v(vec); + Vec3 res = scaler_divide3v(vec, magnitude); + return res; +} + +#ifndef FUN_CALCS +r32 angle3v(Vec3 a, Vec3 b) +{ + Vec3 a_norm = normalize3v(a); + Vec3 b_norm = normalize3v(b); + + r32 dot_product = dot_multiply3v(a_norm, b_norm); + r32 res = acosf(dot_product); + + return res; +} +#endif + +Vec3 cross_multiply3v(Vec3 a, Vec3 b) +{ + Vec3 res; + res.x = (a.y * b.z) - (a.z * b.y); + res.y = (a.z * b.x) - (a.x * b.z); + res.z = (a.x * b.y) - (a.y * b.x); + + return res; +} + +// ============================================== Vec4, Mat4 ============================================== + +Vec4 init4v(r32 x, r32 y, r32 z, r32 w) +{ + Vec4 res; + res.x = x; + res.y = y; + res.z = z; + res.w = w; + + return res; +} + +Mat4 init_value4m(r32 value) +{ + Mat4 res = {0}; + res.data[0][0] = value; + res.data[1][1] = value; + res.data[2][2] = value; + res.data[3][3] = value; + + return res; +} + +// @note: These operations are just defined and not expressed. They are kept here for completeness sake BUT +// since I have not had to do anything related to these, I have not created them. +Vec4 scaler_add4v(Vec4 vec, r32 scaler); +Vec4 scaler_subtract4v(Vec4 vec, r32 scaler); +Vec4 scaler_multiply4v(Vec4 vec, r32 scaler); +Vec4 scaler_divide4v(Vec4 vec, r32 scaler); +Vec4 add4v(Vec4 a, Vec4 b); +Vec4 subtract4v(Vec4 a, Vec4 b); +Vec4 dot_multiply4v(Vec4 a, Vec4 b); + +Mat4 add4m(Mat4 a, Mat4 b) +{ + Mat4 res; + // row 0 + res.data[0][0] = a.data[0][0] + b.data[0][0]; + res.data[0][1] = a.data[0][1] + b.data[0][1]; + res.data[0][2] = a.data[0][2] + b.data[0][2]; + res.data[0][3] = a.data[0][3] + b.data[0][3]; + // row 1 + res.data[1][0] = a.data[1][0] + b.data[1][0]; + res.data[1][1] = a.data[1][1] + b.data[1][1]; + res.data[1][2] = a.data[1][2] + b.data[1][2]; + res.data[1][3] = a.data[1][3] + b.data[1][3]; + // row 2 + res.data[2][0] = a.data[2][0] + b.data[2][0]; + res.data[2][1] = a.data[2][1] + b.data[2][1]; + res.data[2][2] = a.data[2][2] + b.data[2][2]; + res.data[2][3] = a.data[2][3] + b.data[2][3]; + // row 3 + res.data[3][0] = a.data[3][0] + b.data[3][0]; + res.data[3][1] = a.data[3][1] + b.data[3][1]; + res.data[3][2] = a.data[3][2] + b.data[3][2]; + res.data[3][3] = a.data[3][3] + b.data[3][3]; + + return res; +} + +Mat4 subtract4m(Mat4 a, Mat4 b) +{ + Mat4 res; + // row 0 + res.data[0][0] = a.data[0][0] - b.data[0][0]; + res.data[0][1] = a.data[0][1] - b.data[0][1]; + res.data[0][2] = a.data[0][2] - b.data[0][2]; + res.data[0][3] = a.data[0][3] - b.data[0][3]; + // row 1 + res.data[1][0] = a.data[1][0] - b.data[1][0]; + res.data[1][1] = a.data[1][1] - b.data[1][1]; + res.data[1][2] = a.data[1][2] - b.data[1][2]; + res.data[1][3] = a.data[1][3] - b.data[1][3]; + // row 2 + res.data[2][0] = a.data[2][0] - b.data[2][0]; + res.data[2][1] = a.data[2][1] - b.data[2][1]; + res.data[2][2] = a.data[2][2] - b.data[2][2]; + res.data[2][3] = a.data[2][3] - b.data[2][3]; + // row 3 + res.data[3][0] = a.data[3][0] - b.data[3][0]; + res.data[3][1] = a.data[3][1] - b.data[3][1]; + res.data[3][2] = a.data[3][2] - b.data[3][2]; + res.data[3][3] = a.data[3][3] - b.data[3][3]; + + return res; +} + +Vec4 multiply4vm(Vec4 vec, Mat4 mat) +{ + /* + * @note: Incase I get confused about this in the future. + * + * Everything is row-order, which means that things in memory are laid out row first. So with a sample matrix + * we have this order in memory: r1c1 r1c2 r1c3 r1c4 r2c1 ... (r = row, c = column). The same holds true for + * vectors. (maybe move this explanation to the top) + * + * Now, multiply4vm will multiply a vector with a matrix. Conventionally that does not make any sense as + * a vector is usually 4x1 and a matrix ix 4x4. + * What this function considers a vector, while it is a vector, it is infact a row from a matrix, which + * means that the vector is 1x4 and the matrix is 4x4. + * + * The function is meant to supplement the matrix multiplication process to alleviate the multiple lines of code + * we have to write when multiplying the row of a left matrix to each column of the right matrix + */ + Vec4 res = { 0 }; + res.x = (mat.data[0][0] * vec.x) + (mat.data[0][1] * vec.y) + (mat.data[0][2] * vec.z) + (mat.data[0][3] * vec.w); + res.y = (mat.data[1][0] * vec.x) + (mat.data[1][1] * vec.y) + (mat.data[1][2] * vec.z) + (mat.data[1][3] * vec.w); + res.z = (mat.data[2][0] * vec.x) + (mat.data[2][1] * vec.y) + (mat.data[2][2] * vec.z) + (mat.data[2][3] * vec.w); + res.w = (mat.data[3][0] * vec.x) + (mat.data[3][1] * vec.y) + (mat.data[3][2] * vec.z) + (mat.data[3][3] * vec.w); + + return res; +} + +Mat4 multiply4m(Mat4 a, Mat4 b) +{ + Mat4 res = { 0 }; + + res.xyzw[0] = multiply4vm(a.xyzw[0], b); + res.xyzw[1] = multiply4vm(a.xyzw[1], b); + res.xyzw[2] = multiply4vm(a.xyzw[2], b); + res.xyzw[3] = multiply4vm(a.xyzw[3], b); + + return res; +} + +// ==== Matrix Transformation ==== + +Mat4 scaling_matrix4m(r32 x, r32 y, r32 z) // generates a 4x4 scaling matrix for scaling each of the x,y,z axis +{ + Mat4 res = init_value4m(1.0f); + res.data[0][0] = x; + res.data[1][1] = y; + res.data[2][2] = z; + + return res; +} + +Mat4 translation_matrix4m(r32 x, r32 y, r32 z) // generates a 4x4 translation matrix for translation along each of the x,y,z axis +{ + Mat4 res = init_value4m(1.0f); + res.data[0][3] = x; + res.data[1][3] = y; + res.data[2][3] = z; + + return res; +} + +Mat4 rotation_matrix4m(r32 angle_radians, Vec3 axis) // generates a 4x4 rotation matrix for rotation along each of the x,y,z axis +{ + Mat4 res = init_value4m(1.0f); + axis = normalize3v(axis); + + r32 cos_theta = cosf(angle_radians); + r32 sin_theta = sinf(angle_radians); + r32 cos_value = 1.0f - cos_theta; + + res.data[0][0] = (axis.x * axis.x * cos_value) + cos_theta; + res.data[0][1] = (axis.x * axis.y * cos_value) + (axis.z * sin_theta); + res.data[0][2] = (axis.x * axis.z * cos_value) - (axis.y * sin_theta); + + res.data[1][0] = (axis.x * axis.y * cos_value) - (axis.z * sin_theta); + res.data[1][1] = (axis.y * axis.y * cos_value) + cos_theta; + res.data[1][2] = (axis.y * axis.z * cos_value) + (axis.x * sin_theta); + + res.data[2][0] = (axis.x * axis.z * cos_value) + (axis.y * sin_theta); + res.data[2][1] = (axis.z * axis.y * cos_value) - (axis.x * sin_theta); + res.data[2][2] = (axis.z * axis.z * cos_value) + cos_theta; + + return res; +} + +Mat4 perspective_projection_matrix4m(r32 left, r32 right, r32 bottom, r32 top, r32 near, r32 far) +{ + Mat4 res = { 0 }; + + res.data[0][0] = (2.0 * near)/(right - left); + res.data[0][2] = (right + left)/(right - left); + + res.data[1][1] = (2.0 * near)/(top - bottom); + res.data[1][2] = (top + bottom)/(top - bottom); + + res.data[2][2] = -(far + near)/(far - near); + res.data[2][3] = -2.0*far*near/(far - near); + + res.data[3][2] = -1.0; + + return res; +} + +Mat4 perspective4m(r32 fov, r32 aspect_ratio, r32 near, r32 far) +{ + r32 cotangent = 1.0f / tanf(fov / 2.0f); + + Mat4 res = { 0 }; + + res.data[0][0] = cotangent / aspect_ratio; + + res.data[1][1] = cotangent; + + res.data[2][2] = -(far + near) / (far - near); + res.data[2][3] = -2.0f * far * near / (far - near); + + res.data[3][2] = -1.0f; + + return res; +} + +Mat4 lookat4m(Vec3 up, Vec3 forward, Vec3 right, Vec3 position) +{ + /* + * @note: The construction of the lookat matrix is not obvious. For that reason here is the supplemental matrial I have used to understand + * things while I maintain my elementary understanding of linear algebra. + * 1. This youtube video (https://www.youtube.com/watch?v=3ZmqJb7J5wE) helped me understand why we invert matrices. + * It is because, we are moving from the position matrix which is a global to the view matrix which + * is a local. It won't be very clear from this illustration alone, so you would be best served watching the video and recollecting and understanding from there. + * 2. This article (https://twodee.org/blog/17560) derives (or rather shows), in a very shallow way how we get to the look at matrix. + */ + Mat4 res = init_value4m(1.0); + res.xyzw[0] = Vec4{ right.x, right.y, right.z, -dot_multiply3v(right, position) }; + res.xyzw[1] = Vec4{ up.x, up.y, up.z, -dot_multiply3v(up, position) }; + res.xyzw[2] = Vec4{ forward.x, forward.y, forward.z, -dot_multiply3v(forward, position) }; + res.xyzw[3] = Vec4{ 0.0f, 0.0f, 0.0f, 1.0f }; + + return res; +} +#endif diff --git a/source/lessons/models/shaders/model/model.fs.glsl b/source/lessons/models/shaders/model/model.fs.glsl new file mode 100644 index 0000000..87da0b6 --- /dev/null +++ b/source/lessons/models/shaders/model/model.fs.glsl @@ -0,0 +1,152 @@ +#version 330 core + +#define MAX_TEXTURES 32 +struct Material { + sampler2D diffuse[MAX_TEXTURES]; + sampler2D specular[MAX_TEXTURES]; + float shininess; +}; + +struct DirectionalLight { + vec3 direction; + + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +struct PointLight { + vec3 position; + + vec3 ambient; + vec3 diffuse; + vec3 specular; + + // attentuation factors + float kC; + float kL; + float kQ; +}; + +struct SpotLight { + vec3 position; + + vec3 ambient; + vec3 diffuse; + vec3 specular; + + // attenuation factors + float kC; + float kL; + float kQ; + + // vector for the direction directly in front of the spotlight + vec3 front; + + // spot radius + float radius_inner; + float radius_outer; // to smooth out the light + +}; + +// this is the result of a light creation. This contains the multipliers for each kind of a light we want +// to have. +struct LightFactor { + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +in vec2 TexCoords; +in vec3 FragNormal; +in vec3 VertexWorldPos; +uniform Material material; +uniform PointLight pointLight; +uniform DirectionalLight dirLight; +uniform vec3 cameraPosition; + +out vec4 FragColor; + +LightFactor make_directional_light(DirectionalLight light, vec3 CONST_viewDir) { + LightFactor res; + + vec3 DL_lightDir = normalize(-light.direction); + res.ambient = light.ambient; + + float DL_diffuseStrength = max(dot(DL_lightDir, FragNormal), 0.0); + res.diffuse = light.diffuse * DL_diffuseStrength; + + vec3 DL_reflectDir = reflect(-DL_lightDir, FragNormal); + float DL_specularity = max(dot(CONST_viewDir, DL_reflectDir), 0.0); + float DL_shinePower = pow(DL_specularity, material.shininess); + res.specular = light.specular * DL_shinePower; + + return res; +}; + +LightFactor make_point_light(PointLight light, vec3 CONST_viewDir) { + LightFactor res; + + float PL_lightDistance = length(light.position - VertexWorldPos); + float PL_attenuationFactor = 1.0 / + (light.kC + (light.kL * PL_lightDistance) + (light.kQ * PL_lightDistance * PL_lightDistance)); + res.ambient = PL_attenuationFactor * light.ambient; + + vec3 PL_lightDir = normalize(light.position - VertexWorldPos); + float PL_diffuseStrength = max(dot(PL_lightDir, FragNormal), 0.0); + res.diffuse = PL_attenuationFactor * light.diffuse * PL_diffuseStrength; + + vec3 PL_reflectDir = reflect(-PL_lightDir, FragNormal); + float PL_specularity = max(dot(CONST_viewDir, PL_reflectDir), 0.0); + float PL_shinePower = pow(PL_specularity, material.shininess); + res.specular = PL_attenuationFactor * PL_shinePower * light.specular; + + return res; +} + +LightFactor make_spot_light(SpotLight light, vec3 CONST_viewDir) { + LightFactor res; + + float SL_lightDistance = length(light.position - VertexWorldPos); + float SL_attenuationFactor = 1.0 / + (light.kC + (light.kL * SL_lightDistance) + (light.kQ * SL_lightDistance * SL_lightDistance)); + vec3 SL_lightDir = normalize(light.position - VertexWorldPos); + + res.ambient = SL_attenuationFactor * light.ambient; + + float SL_diffAmount = dot(SL_lightDir, normalize(-light.front)); + float SL_spotLightFadeFactor = clamp((SL_diffAmount - light.radius_outer)/(light.radius_inner - light.radius_outer), 0.0f, 1.0f); + float SL_diffuseStrength = max(dot(SL_lightDir, FragNormal), 0.0); + res.diffuse = SL_spotLightFadeFactor * SL_attenuationFactor * light.diffuse * SL_diffuseStrength; + + vec3 SL_reflectDir = reflect(-SL_lightDir, FragNormal); + float SL_specularity = max(dot(CONST_viewDir, SL_reflectDir), 0.0); + float SL_shinePower = pow(SL_specularity, material.shininess); + res.specular = SL_spotLightFadeFactor * SL_attenuationFactor * SL_shinePower * light.specular; + + return res; +} + +void main() { + vec3 CONST_viewDir = normalize(cameraPosition - VertexWorldPos); + vec3 combinedAmbience = vec3(0.0); + vec3 combinedDiffuse = vec3(0.0); + vec3 combinedSpecular = vec3(0.0); + + LightFactor DL_factors = make_directional_light(dirLight, CONST_viewDir); + combinedAmbience += DL_factors.ambient; + combinedDiffuse += DL_factors.diffuse; + combinedSpecular += DL_factors.specular; + + //LightFactor PL_factors = make_point_light(pointLight, CONST_viewDir); + //combinedAmbience += PL_factors.ambient; + //combinedDiffuse += PL_factors.diffuse; + //combinedSpecular += PL_factors.specular; + + vec3 ambientLight = combinedAmbience * vec3(texture(material.diffuse[0], TexCoords)); + vec3 diffuseLight = combinedDiffuse * vec3(texture(material.diffuse[0], TexCoords)); + vec3 specularLight = combinedSpecular * vec3(texture(material.specular[0], TexCoords)); + + vec3 color = ambientLight + diffuseLight + specularLight; + FragColor = vec4(color, 1.0); +}; diff --git a/source/lessons/models/shaders/model/model.vs.glsl b/source/lessons/models/shaders/model/model.vs.glsl new file mode 100644 index 0000000..da394cf --- /dev/null +++ b/source/lessons/models/shaders/model/model.vs.glsl @@ -0,0 +1,25 @@ +#version 330 core +layout(location=0) in vec3 aPos; +layout(location=1) in vec3 aNormal; +layout(location=2) in vec2 aTex; + +uniform mat4 Model; +uniform mat4 View; +uniform mat4 Projection; + +out vec2 TexCoords; +out vec3 VertexWorldPos; +out vec3 FragNormal; + +// @note: I still do not fully understand how the FragNormal calculation works. Need to make sure I intuitively +// get that + +void main() { + gl_Position = Projection*View*Model*vec4(aPos, 1.0); + + VertexWorldPos = vec3(Model * vec4(aPos, 1.0)); + FragNormal = mat3(transpose(inverse(Model))) * aNormal; + FragNormal = normalize(FragNormal); + TexCoords = aTex; +}; + |