0xdeadbeer/rendlib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add probe functions for user customization

Browse Source 
custom probes inside the library allow the user developer
to run useful code along the renderer loop
This commit is contained in:
Kevin J. 2024-10-08 23:36:14 +02:00
parent 950fb4d353
commit bca01fe3cd
3 changed files with 167 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
dev.c
View File

@ -1,9 +1,152 @@
#include <stdlib.h>
#include <stdio.h>
#include <GLFW/glfw3.h>
#include "include/rendlib.h"
#include "include/camera.h"
#include "include/object.h"
#define INPUT_ESCAPE 0b00000001
#define INPUT_RELOAD 0b00000010
#define INPUT_LEFT 0b00000100
#define INPUT_RIGHT 0b00001000
#define INPUT_DOWN 0b00010000
#define INPUT_UP 0b00100000
#define MOVEMENT_SPEED 0.2f
char input = 0;
void keyboardp(int key, int scancode, int action, int mods) {
if (action == GLFW_PRESS) {
switch (key) {
case GLFW_KEY_Q:
case GLFW_KEY_ESCAPE:
input |= INPUT_ESCAPE;
break;
case GLFW_KEY_R:
input |= INPUT_RELOAD;
break;
case GLFW_KEY_A:
case GLFW_KEY_LEFT:
input |= INPUT_LEFT;
break;
case GLFW_KEY_D:
case GLFW_KEY_RIGHT:
input |= INPUT_RIGHT;
break;
case GLFW_KEY_S:
case GLFW_KEY_DOWN:
input |= INPUT_DOWN;
break;
case GLFW_KEY_W:
case GLFW_KEY_UP:
input |= INPUT_UP;
break;
}
} else if (action == GLFW_RELEASE) {
switch (key) {
case GLFW_KEY_A:
case GLFW_KEY_LEFT:
input &= ~INPUT_LEFT;
break;
case GLFW_KEY_D:
case GLFW_KEY_RIGHT:
input &= ~INPUT_RIGHT;
break;
case GLFW_KEY_S:
case GLFW_KEY_DOWN:
input &= ~INPUT_DOWN;
break;
case GLFW_KEY_W:
case GLFW_KEY_UP:
input &= ~INPUT_UP;
break;
}
}
}
int warped_pointer = 0;
int first_pointer = 1;
void mousep(double x, double y) {
GLint screen_viewport[4];
if (warped_pointer == 1) {
warped_pointer = 0;
return;
}
warped_pointer = 1;
glGetIntegerv(GL_VIEWPORT, screen_viewport);
GLFWwindow *w = glfwGetCurrentContext();
glfwSetCursorPos(w, (screen_viewport[2]/2), (screen_viewport[3]/2));
if (first_pointer == 1) {
first_pointer = 0;
return;
}
float offset_x = (float) (x - (screen_viewport[2]/2)) * ac->sensitivity;
float offset_y = (float) (y - (screen_viewport[3]/2)) * ac->sensitivity;
ac->yaw += offset_x;
ac->pitch -= offset_y;
if (ac->pitch < -89.9f) {
ac->pitch = -89.9f;
}
if (ac->pitch > 89.9f) {
ac->pitch = 89.9f;
}
vec3 view_direction = { cos(glm_rad(ac->yaw)) * cos(glm_rad(ac->pitch)),
sin(glm_rad(ac->pitch)),
sin(glm_rad(ac->yaw)) * cos(glm_rad(ac->pitch))
};
glm_normalize_to(view_direction, ac->front);
}
void periodic_input(void) {
int ret = 0;
if (input & INPUT_ESCAPE) {
exit(EXIT_SUCCESS);
input &= ~INPUT_ESCAPE;
}
if (input & INPUT_LEFT) {
vec3 side_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED, MOVEMENT_SPEED};
vec3 camera_side;
glm_cross(ac->front, ac->up, camera_side);
glm_normalize(camera_side);
glm_vec3_mul(camera_side, side_scalar, camera_side);
glm_vec3_sub(ac->pos, camera_side, ac->pos);
}
if (input & INPUT_RIGHT) {
vec3 side_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED, MOVEMENT_SPEED};
vec3 camera_side;
glm_cross(ac->front, ac->up, camera_side);
glm_normalize(camera_side);
glm_vec3_mul(camera_side, side_scalar, camera_side);
glm_vec3_add(ac->pos, camera_side, ac->pos);
}
if (input & INPUT_DOWN) {
vec3 front_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED, MOVEMENT_SPEED};
glm_vec3_mul(front_scalar, ac->front, front_scalar);
glm_vec3_sub(ac->pos, front_scalar, ac->pos);
}
if (input & INPUT_UP) {
vec3 front_scalar = {MOVEMENT_SPEED, MOVEMENT_SPEED, MOVEMENT_SPEED};
glm_vec3_mul(front_scalar, ac->front, front_scalar);
glm_vec3_add(ac->pos, front_scalar, ac->pos);
}
}
void updatep(void) {
periodic_input();
}
int main(int argc, char *argv[]) {
int ret = rendlib_start_window(argc, argv);
if (ret < 0) {
@ -11,6 +154,10 @@ int main(int argc, char *argv[]) {
return EXIT_FAILURE;
}
keyboard_probe = &keyboardp;
mouse_probe = &mousep;
update_probe = &updatep;
struct model *m = load_model("assets/models/sphere.obj");
if (m == NULL) {
fprintf(stderr, "--error: loading model\n");

14
include/rendlib.h
View File

@ -1,13 +1,6 @@
#ifndef RENDLIB_H
#define RENDLIB_H
#define RENDLIB_INPUT_ESC 0b00000001
#define RENDLIB_INPUT_REL 0b00000010
#define RENDLIB_INPUT_LEFT 0b00000100
#define RENDLIB_INPUT_RIGHT 0b00001000
#define RENDLIB_INPUT_BACKW 0b00010000
#define RENDLIB_INPUT_FORW 0b00100000
enum errs {
err_glfw_init = -1,
err_glfw_win = -2,
@ -15,8 +8,13 @@ enum errs {
err_shaders_init = -4,
};
extern struct camera *active_camera;
extern struct camera *ac;
extern struct object *objects;
extern void (*keyboard_probe)(int key, int scancode, int action, int mods);
extern void (*mouse_probe)(double x, double y);
extern void (*update_probe)(void);
int rendlib_start_window(int argc, char *argv[]);
int rendlib_render(void);

144
rendlib.c
View File

@ -16,10 +16,13 @@ char *window_title = "rendlib window";
struct camera *ac;
void (*keyboard_probe)(int key, int scancode, int action, int mods);
void (*mouse_probe)(double x, double y);
void (*update_probe)(void);
float top_movement_speed = 0.4f;
vec3 speed = { 0.0f, 0.0f, 0.0f };
GLint screen_viewport[4];
char input = 0;
struct object *objects;
@ -127,50 +130,6 @@ int load_shaders(void) {
}
void handle_input(void) {
int ret = 0;
if (input & RENDLIB_INPUT_ESC) {
exit(EXIT_SUCCESS);
input &= ~RENDLIB_INPUT_ESC;
}
if (input & RENDLIB_INPUT_REL) {
ret = load_shaders();
if (ret < 0) {
fprintf(stderr, "--error: reloading shaders\n");
exit(EXIT_FAILURE);
}
input &= ~RENDLIB_INPUT_REL;
}
if (input & RENDLIB_INPUT_LEFT) {
vec3 side_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
vec3 camera_side;
glm_cross(ac->front, ac->up, camera_side);
glm_normalize(camera_side);
glm_vec3_mul(camera_side, side_scalar, camera_side);
glm_vec3_sub(ac->pos, camera_side, ac->pos);
}
if (input & RENDLIB_INPUT_RIGHT) {
vec3 side_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
vec3 camera_side;
glm_cross(ac->front, ac->up, camera_side);
glm_normalize(camera_side);
glm_vec3_mul(camera_side, side_scalar, camera_side);
glm_vec3_add(ac->pos, camera_side, ac->pos);
}
if (input & RENDLIB_INPUT_BACKW) {
vec3 front_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
glm_vec3_mul(front_scalar, ac->front, front_scalar);
glm_vec3_sub(ac->pos, front_scalar, ac->pos);
}
if (input & RENDLIB_INPUT_FORW) {
vec3 front_scalar = {top_movement_speed, top_movement_speed, top_movement_speed };
glm_vec3_mul(front_scalar, ac->front, front_scalar);
glm_vec3_add(ac->pos, front_scalar, ac->pos);
}
}
void window_size(GLFWwindow *w, int width, int height) {
@ -261,100 +220,19 @@ void rendlib_bake_graphics(void) {
glEnable(GL_DEPTH_TEST);
}
void keyboard(GLFWwindow *w, int key, int scancode, int action, int mods) {
if (action == GLFW_PRESS) {
switch (key) {
case GLFW_KEY_Q:
case GLFW_KEY_ESCAPE:
input |= RENDLIB_INPUT_ESC;
break;
case GLFW_KEY_R:
input |= RENDLIB_INPUT_REL;
break;
case GLFW_KEY_A:
case GLFW_KEY_LEFT:
input |= RENDLIB_INPUT_LEFT;
break;
case GLFW_KEY_D:
case GLFW_KEY_RIGHT:
input |= RENDLIB_INPUT_RIGHT;
break;
case GLFW_KEY_S:
case GLFW_KEY_DOWN:
input |= RENDLIB_INPUT_BACKW;
break;
case GLFW_KEY_W:
case GLFW_KEY_UP:
input |= RENDLIB_INPUT_FORW;
break;
case GLFW_KEY_F11: {
GLFWmonitor *m = glfwGetPrimaryMonitor();
const GLFWvidmode *vm = glfwGetVideoMode(m);
GLFWwindow *w = glfwGetCurrentContext();
glfwSetWindowMonitor(w, m, 0, 0, vm->width, vm->height, vm->refreshRate);
update_screen_viewport(0, 0, vm->width, vm->height);
break;
}
if (keyboard_probe == NULL) {
return;
}
} else if (action == GLFW_RELEASE) {
switch (key) {
case GLFW_KEY_A:
case GLFW_KEY_LEFT:
input &= ~RENDLIB_INPUT_LEFT;
break;
case GLFW_KEY_D:
case GLFW_KEY_RIGHT:
input &= ~RENDLIB_INPUT_RIGHT;
break;
case GLFW_KEY_S:
case GLFW_KEY_DOWN:
input &= ~RENDLIB_INPUT_BACKW;
break;
case GLFW_KEY_W:
case GLFW_KEY_UP:
input &= ~RENDLIB_INPUT_FORW;
break;
}
}
(keyboard_probe)(key, scancode, action, mods);
}
int warped_pointer = 0;
int first_pointer = 1;
void mouse_motion(GLFWwindow *window, double x, double y) {
if (warped_pointer == 1) {
warped_pointer = 0;
if (mouse_probe == NULL) {
return;
}
warped_pointer = 1;
glGetIntegerv(GL_VIEWPORT, screen_viewport);
GLFWwindow *w = glfwGetCurrentContext();
glfwSetCursorPos(w, (screen_viewport[2]/2), (screen_viewport[3]/2));
if (first_pointer == 1) {
first_pointer = 0;
return;
}
float offset_x = (float) (x - (screen_viewport[2]/2)) * ac->sensitivity;
float offset_y = (float) (y - (screen_viewport[3]/2)) * ac->sensitivity;
ac->yaw += offset_x;
ac->pitch -= offset_y;
if (ac->pitch < -89.9f) {
ac->pitch = -89.9f;
}
if (ac->pitch > 89.9f) {
ac->pitch = 89.9f;
}
vec3 view_direction = { cos(glm_rad(ac->yaw)) * cos(glm_rad(ac->pitch)),
sin(glm_rad(ac->pitch)),
sin(glm_rad(ac->yaw)) * cos(glm_rad(ac->pitch))
};
glm_normalize_to(view_direction, ac->front);
(mouse_probe)(x, y);
}
int rendlib_start_window(int argc, char *argv[]) {
@ -403,6 +281,10 @@ int rendlib_render(void) {
}
rendlib_bake_graphics();
for (;;) {
if (update_probe != NULL) {
(update_probe)();
}
display();
}
return 0;