From 3b24a477cf566296aa758058aaca96cf0c117141 Mon Sep 17 00:00:00 2001 From: jvech Date: Thu, 25 Aug 2022 21:39:11 -0500 Subject: feat: linear library implemented --- src/linear.c | 243 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/linear.h | 38 ++++++++++ src/main.c | 74 +++++++++++------- 3 files changed, 326 insertions(+), 29 deletions(-) (limited to 'src') diff --git a/src/linear.c b/src/linear.c index e69de29..06c2e33 100644 --- a/src/linear.c +++ b/src/linear.c @@ -0,0 +1,243 @@ +#include "linear.h" +#include + +mat4 +linearLookAt(vec3 position, vec3 target, vec3 world_up) +{ + mat4 out = linearMat4Identity(); + mat4 translate; + vec3 cam_dir, cam_right, cam_up; + /* position - target */ + cam_dir = linearVec3Add(position, linearVec3ScalarMulp(target, -1.0)); + cam_dir = linearVec3Normalize(cam_dir); + + cam_right = linearVec3CrossProduct(world_up, cam_dir); + cam_right = linearVec3Normalize(cam_right); + + cam_up = linearVec3CrossProduct(cam_dir, cam_right); + + int i; + for (i = 0; i < 3; i++) { + out.matrix[0][i] = cam_right.vector[i]; + out.matrix[1][i] = cam_up.vector[i]; + out.matrix[2][i] = cam_dir.vector[i]; + } + translate = linearTranslate(-position.vector[0], + -position.vector[1], + -position.vector[2]); + return linearMat4Mul(out, translate); +} + +mat4 +linearPerspective(float FoV, float ratio, float near, float far) +{ + mat4 out = linearMat4Fill(0.0); + float FoV_radians = FoV * M_PI / 180; + float width = near * tanf(FoV_radians) * ratio; + float height = near * tanf(FoV_radians); + + out.matrix[0][0] = near / width; + out.matrix[1][1] = near / height; + out.matrix[2][2] = -(far + near) / (far - near); + out.matrix[2][3] = -2 * far * near / (far - near); + out.matrix[3][2] = -1; + return out; +} + +mat4 +linearTranslate(float T_x, float T_y, float T_z) +{ + mat4 out = linearMat4Identity(); + out.matrix[0][3] = T_x; + out.matrix[1][3] = T_y; + out.matrix[2][3] = T_z; + return out; +} + +mat4 +linearTranslatev(vec3 T) +{ + return linearTranslate(T.vector[0], T.vector[1], T.vector[2]); +} + +mat4 +linearScale(float S_x, float S_y, float S_z) +{ + mat4 out = linearMat4Identity(); + out.matrix[0][0] = S_x; + out.matrix[1][1] = S_y; + out.matrix[2][2] = S_z; + return out; +} + +mat4 +linearScalev(vec3 S) +{ + return linearScale(S.vector[0], S.vector[1], S.vector[2]); +} + +mat4 +linearRotate(float degree, vec3 R_xyz) +{ + mat4 out = linearMat4Identity(); + vec3 R_xyz_normalized = linearVec3Normalize(R_xyz); + float radians = degree * M_PI/180.0; + float Rx = R_xyz_normalized.vector[0]; + float Ry = R_xyz_normalized.vector[1]; + float Rz = R_xyz_normalized.vector[2]; + float rcos = cosf(radians); + float rsin = sinf(radians); + + out.matrix[0][0] = rcos + pow(Rx, 2) * ( 1 - rcos); + out.matrix[0][1] = Rx * Ry * (1 - rcos) - Rz * rsin; + out.matrix[0][2] = Rx * Rz * (1 - rcos) + Ry * rsin; + + out.matrix[1][0] = Rx * Ry * (1 - rcos) + Rz * rsin; + out.matrix[1][1] = rcos + pow(Ry, 2) * ( 1 - rcos); + out.matrix[1][2] = Ry * Rz * (1 - rcos) - Rx * rsin; + + out.matrix[2][0] = Rz * Rx * (1 - rcos) - Ry * rsin; + out.matrix[2][1] = Ry * Rz * (1 - rcos) + Rx * rsin; + out.matrix[2][2] = rcos + pow(Rz, 2) * ( 1 - rcos); + return out; +} + +mat4 +linearMat4Fill(float value) +{ + int i, j; + mat4 out; + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + out.matrix[i][j] = value; + } + } + return out; +} + +mat4 +linearMat4Identity() +{ + int i, j; + mat4 out; + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + if (i == j) out.matrix[i][j] = 1.0; + else out.matrix[i][j] = 0.0; + } + } + return out; +} + +mat4 +linearMat4Transpose(mat4 x) +{ + mat4 out; + int i, j; + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + out.matrix[i][j] = x.matrix[j][i]; + } + } + return out; +} + +mat4 +linearMat4Mul(mat4 x1, mat4 x2) +{ + mat4 out; + int i, j, k; + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + out.matrix[i][j] = 0.0; + for (k = 0; k < 4; k++) + out.matrix[i][j] += x1.matrix[i][k] * x2.matrix[k][j]; + } + } + return out; +} + +mat4 +linearMat4Add(mat4 x1, mat4 x2) +{ + int i, j; + mat4 out; + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + out.matrix[i][j] = x1.matrix[i][j] + x2.matrix[i][j]; + } + } + return out; +} + +float +linearMat4Det(mat4 x) +{ + return 0.0; +} + +vec3 +linearVec3ScalarMulp(vec3 x, float scalar) +{ + vec3 out; + int i; + for (i = 0; i < 3; i++) { + out.vector[i] = scalar * x.vector[i]; + } + return out; +} + +vec3 +linearVec3(float x, float y, float z) +{ + vec3 out; + out.vector[0] = x; + out.vector[1] = y; + out.vector[2] = z; + return out; +} + +vec3 +linearVec3Add(vec3 x, vec3 y) +{ + vec3 out; + int i; + for (i = 0; i < 3; i++) { + out.vector[i] = x.vector[i] + y.vector[i]; + } + return out; +} + +vec3 +linearVec3Normalize(vec3 x) +{ + vec3 out; + float norm = sqrtf(linearVec3DotProduct(x, x)); + int i; + if (norm == 0) return x; + for (i = 0; i < 3; i++) { + out.vector[i] = x.vector[i] / norm; + } + return out; +} + +vec3 +linearVec3CrossProduct(vec3 x, vec3 y) +{ + vec3 out; + out.vector[0] = x.vector[1] * y.vector[2] - x.vector[2] * y.vector[1]; + out.vector[1] = - x.vector[0] * y.vector[2] + x.vector[2] * y.vector[0]; + out.vector[2] = x.vector[0] * y.vector[1] - x.vector[1] * y.vector[0]; + return out; +} + +float +linearVec3DotProduct(vec3 x, vec3 y) +{ + float out = 0; + int i; + for (i = 0; i < 3; i++) { + out += x.vector[i] * y.vector[i]; + } + return out; +} diff --git a/src/linear.h b/src/linear.h index e69de29..86b93d7 100644 --- a/src/linear.h +++ b/src/linear.h @@ -0,0 +1,38 @@ +#ifndef __LINEAR__ +#define __LINEAR__ + +#ifndef M_PI +#define M_PI (3.14159265358979323846) +#endif + +typedef struct { + float matrix[4][4]; +} mat4; + +typedef struct { + float vector[3]; +} vec3; + +mat4 linearTranslatev(vec3 translate_vector); //TODO +mat4 linearScalev(vec3 scale_vector); //TODO +mat4 linearTranslate(float translate_x, float translate_y, float translate_z); +mat4 linearScale(float scale_x, float scale_y, float scale_z); +mat4 linearRotate(float degree, vec3 rotation_axis); +mat4 linearPerspective(float FoV, float ratio, float near, float far); +mat4 linearLookAt(vec3 position, vec3 target, vec3 up); + +mat4 linearMat4Fill(float value); +mat4 linearMat4Identity(); +mat4 linearMat4Mul(mat4 x1, mat4 x2); +mat4 linearMat4Transpose(mat4 x); +mat4 linearMat4Inv(mat4 x); //TODO +mat4 linearMat4Add(mat4 x1, mat4 x2); //TODO +float linearMat4Det(mat4 x); //TODO + +vec3 linearVec3(float x, float y, float z); +vec3 linearVec3Normalize(vec3 vector); +vec3 linearVec3Add(vec3 vector1, vec3 vector2); +vec3 linearVec3ScalarMulp(vec3 vector, float scalar); +vec3 linearVec3CrossProduct(vec3 vector1, vec3 vector2); +float linearVec3DotProduct(vec3 vector1, vec3 vector2); +#endif diff --git a/src/main.c b/src/main.c index af2c65a..27181ef 100644 --- a/src/main.c +++ b/src/main.c @@ -2,25 +2,32 @@ #include #include #include +#include #include #include -#include "shader.h" #include "main.h" +#include "linear.h" +#include "shader.h" float vertices[] = { - -0.5f, -0.5f, 0.0f, - 0.5f, -0.5f, 0.0f, - 0.0f, 0.5f, 0.0f + -0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 0.0f, + 0.5f, -0.5f, 0.0f, 1.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.0f, 1.0, 1.0f, 0.0f, + 0.5f, 0.5f, 0.0f, 1.0, 1.0f, 0.0f, +}; + +unsigned int indices[] = { + 0, 1, 2, + 2, 3, 1 }; -//static void sysError(const char *msg); static void userError(const char *msg, const char *detail); static void glfw_size_callback(GLFWwindow *window, int width, int height); -static void processInput(GLFWwindow *window, struct Background *c); +static void processInput(GLFWwindow *window); -void +void userError(const char *msg, const char *detail) { fprintf(stderr, "%s: %s\n", msg, detail); @@ -33,19 +40,19 @@ glfw_size_callback(GLFWwindow *window, int width, int height) glViewport(0, 0, width, height); } -static void -processInput(GLFWwindow *window, struct Background *c) +void +processInput(GLFWwindow *window) { if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS - || glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) { + || glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) glfwSetWindowShouldClose(window, 1); - } else if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS - && glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS - && c->R >= 0.0) { - c->R -= 0.1; - } else if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS && c->R <= 1.0) { - c->R += 0.1; - } + + if (glfwGetKey(window, GLFW_KEY_1) == GLFW_PRESS) + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + if (glfwGetKey(window, GLFW_KEY_2) == GLFW_PRESS) + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + if (glfwGetKey(window, GLFW_KEY_3) == GLFW_PRESS) + glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); } int main() @@ -74,42 +81,51 @@ int main() userError("glewInit() failed", (const char *)glewGetErrorString(glewErrno)); } - struct Background colors = {.R = 0.0, .G = 0.0, .B = 0.0, .A = 0.0}; - - unsigned int VBO, VAO; + unsigned int VBO, VAO, EBO; glGenVertexArrays(1, &VAO); - glBindVertexArray(VAO); - glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); - glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); + + glBindVertexArray(VAO); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0); glEnableVertexAttribArray(0); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); unsigned int shaderProgram = shaderCreateProgram("shaders/vertex.vsh", "shaders/fragment.vsh"); + unsigned int transformLoc; + mat4 transform; + while (!glfwWindowShouldClose(window)) { - processInput(window, &colors); + processInput(window); - glClearColor(colors.R, colors.G, colors.B, colors.A); + glClearColor(0.2f, 0.2f, 0.2f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); glUseProgram(shaderProgram); glBindVertexArray(VAO); - glDrawArrays(GL_TRIANGLES, 0, 3); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + + transformLoc = glGetUniformLocation(shaderProgram, "trans"); + transform = linearRotate(45.0, linearVec3(0, 0, 1)); + glUniformMatrix4fv(transformLoc, 1, GL_FALSE, transform.matrix[0]); + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glfwSwapBuffers(window); glfwPollEvents(); } - int nattributes; - glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nattributes); - printf("%d\n", nattributes); glfwTerminate(); return 0; } -- cgit v1.2.3-70-g09d2