nishi/nishbox
1
Fork 0
mirror of https://github.com/nishiowo/nishbox synced 2025-04-21 20:24:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

removed glu and removed odemath dependency from gf_math

Browse Source
This commit is contained in:
NishiOwO 2025-04-16 13:58:55 +09:00
parent c669fd5bbe
commit c82539d5a5
No known key found for this signature in database
GPG Key ID: 27EF69B208EB9343
16 changed files with 204 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engine/gf_draw_common.c
View File

@ -76,8 +76,8 @@ void gf_draw_reshape(gf_draw_t* draw) { gf_draw_driver_reshape(draw); }
/* Runs every frame */
void gf_draw_frame(gf_draw_t* draw) {
gf_color_t color;
float z = 16;
gf_graphic_color_t color;
float z = 16;
color.r = color.g = color.b = color.a = 255;
if(draw->draw_3d) {
}

6
engine/gf_graphic_common.c
View File

@ -14,9 +14,9 @@
/* Standard */
#include <string.h>
void gf_graphic_fill_rect(gf_draw_t* draw, float x, float y, float w, float h, gf_color_t color) { gf_graphic_fill_polygon(draw, color, GF_GRAPHIC_2D, 4, x, y, x, y + h, x + w, y + h, x + w, y); }
void gf_graphic_fill_rect(gf_draw_t* draw, float x, float y, float w, float h, gf_graphic_color_t color) { gf_graphic_fill_polygon(draw, color, GF_GRAPHIC_2D, 4, x, y, x, y + h, x + w, y + h, x + w, y); }
void gf_graphic_text(gf_draw_t* draw, float x, float y, float size, const char* text, gf_color_t color) {
void gf_graphic_text(gf_draw_t* draw, float x, float y, float size, const char* text, gf_graphic_color_t color) {
int i;
for(i = 0; text[i] != 0; i++) {
gf_graphic_draw_texture_2d(draw, x + i * (size * GF_GRAPHIC_FONT_ASPECT_X / GF_GRAPHIC_FONT_ASPECT_Y), y, size * GF_GRAPHIC_FONT_ASPECT_X / GF_GRAPHIC_FONT_ASPECT_Y, size, draw->font[text[i]], color);
@ -25,4 +25,4 @@ void gf_graphic_text(gf_draw_t* draw, float x, float y, float size, const char*
float gf_graphic_text_width(gf_draw_t* draw, float size, const char* text) { return (float)strlen(text) * (size * GF_GRAPHIC_FONT_ASPECT_X / GF_GRAPHIC_FONT_ASPECT_Y); }
void gf_graphic_draw_texture_2d(gf_draw_t* draw, float x, float y, float w, float h, gf_texture_t* texture, gf_color_t color) { gf_graphic_draw_texture_polygon(draw, texture, color, GF_GRAPHIC_2D, 4, 0.0, 0.0, x, y, 0.0, 1.0, x, y + h, 1.0, 1.0, x + w, y + h, 1.0, 0.0, x + w, y); }
void gf_graphic_draw_texture_2d(gf_draw_t* draw, float x, float y, float w, float h, gf_texture_t* texture, gf_graphic_color_t color) { gf_graphic_draw_texture_polygon(draw, texture, color, GF_GRAPHIC_2D, 4, 0.0, 0.0, x, y, 0.0, 1.0, x, y + h, 1.0, 1.0, x + w, y + h, 1.0, 0.0, x + w, y); }

10
engine/gf_gui.c
View File

@ -15,8 +15,8 @@
#include <stdlib.h>
#include <string.h>
gf_color_t gf_gui_base_color;
gf_color_t gf_gui_font_color;
gf_graphic_color_t gf_gui_base_color;
gf_graphic_color_t gf_gui_font_color;
gf_gui_t* gf_gui_create(gf_draw_t* draw) {
gf_gui_t* gui = malloc(sizeof(*gui));
@ -34,9 +34,9 @@ gf_gui_t* gf_gui_create(gf_draw_t* draw) {
/* note... left top should be the lightest in the border */
void gf_gui_draw_box(gf_gui_t* gui, int mul, float x, float y, float w, float h) {
const int color_diff = 32; /* color diff */
const float bw = 2; /* border width */
gf_color_t col;
const int color_diff = 32; /* color diff */
const float bw = 2; /* border width */
gf_graphic_color_t col;
int cd = mul * color_diff;

72
engine/gf_math.c
View File

@ -1,7 +1,6 @@
#include <gf_pre.h>
/* External library */
#include <ode/odemath.h>
/* Interface */
#include <gf_math.h>
@ -13,34 +12,51 @@
#include <stdlib.h>
#include <math.h>
float gf_math_log2(float x) { return log(x) / log(2); }
double gf_math_log2(double x) { return log(x) / log(2); }
void gf_math_normal(gf_vector_t* r, gf_vector_t v0, gf_vector_t v1, gf_vector_t v2) {
int i;
dReal length;
gf_vector_t vec;
dReal res[3];
dReal tmp0[3];
dReal tmp1[3];
dReal a[3]; /* v1 - v0 */
dReal b[3]; /* v2 - v0 */
void gf_math_normalize(gf_math_vector_t v) {
double x = v[0];
double y = v[1];
double z = v[2];
double length;
GF_VECTOR_COPY(tmp0, v1);
GF_VECTOR_COPY(tmp1, v0);
dSubtractVectors3(a, tmp0, tmp1); /* v1 - v0 */
x *= x;
y *= y;
z *= z;
GF_VECTOR_COPY(tmp0, v2);
GF_VECTOR_COPY(tmp1, v0);
dSubtractVectors3(b, tmp0, tmp1); /* v2 - v0 */
dCalcVectorCross3(res, a, b);
length = dCalcVectorLength3(res);
GF_VECTOR_COPY(res, vec);
vec[0] /= length;
vec[1] /= length;
vec[2] /= length;
memcpy(*r, vec, sizeof(vec));
length = sqrt(x + y + z);
if(length > 0) {
length = (double)1 / length;
} else {
length = 0;
}
v[0] *= length;
v[1] *= length;
v[2] *= length;
}
void gf_math_normal(gf_math_vector_t r, gf_math_vector_t v0, gf_math_vector_t v1, gf_math_vector_t v2) {
gf_math_vector_t tmp0;
gf_math_vector_t tmp1;
gf_math_subtract(tmp0, v1, v0);
gf_math_subtract(tmp1, v2, v0);
gf_math_multiply(r, tmp0, tmp1);
gf_math_normalize(r);
}
void gf_math_subtract(gf_math_vector_t r, gf_math_vector_t v0, gf_math_vector_t v1) {
r[0] = v0[0] - v1[0];
r[1] = v0[1] - v1[1];
r[2] = v0[2] - v1[2];
}
void gf_math_multiply(gf_math_vector_t r, gf_math_vector_t v0, gf_math_vector_t v1) {
r[0] = v0[1] * v1[2] - v0[2] * v1[1];
r[1] = v0[2] * v1[0] - v0[0] * v1[2];
r[2] = v0[0] * v1[1] - v0[1] * v1[0];
}
double gf_math_cot(double x) { return (double)1 / tan(x); }

38
engine/graphic/opengl/gf_driver.c
View File

@ -24,35 +24,11 @@
#include <string.h>
#include <math.h>
/**
* @~english
* @brief White light
*/
GLfloat lightwht[] = {1.0, 1.0, 1.0, 1.0};
/**
* @~english
* @brief Gray light
*/
GLfloat lightgry[] = {0.6, 0.6, 0.6, 1.0};
/**
* @~english
* @brief Dim light
*/
GLfloat lightdim[] = {0.2, 0.2, 0.2, 1.0};
/**
* @~english
* @brief Black light
*/
GLfloat lightblk[] = {0.0, 0.0, 0.0, 1.0};
/**
* @~english
* @brief Calculate the nearest 2^n value to x
* @param x Number
*/
#define NEAREST_POW2(x) pow((2), gf_math_log2((int)(x) + 1))
gf_draw_driver_texture_t* gf_draw_driver_register_texture(gf_draw_t* draw, int width, int height, int* iwidth, int* iheight, unsigned char* data) {
@ -98,6 +74,8 @@ void gf_draw_driver_init(gf_draw_t* draw) {
int w, h, ch;
draw->driver = malloc(sizeof(*draw->driver));
gf_log_function(NULL, "OpenGL renderer: %s", (char*)glGetString(GL_RENDERER));
glEnable(GL_BLEND);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
@ -135,8 +113,6 @@ void gf_draw_driver_init(gf_draw_t* draw) {
gf_log_function(NULL, "Registered %d glyphs", sizeof(gf_font) / sizeof(gf_font[0]));
glClearColor(0, 0, 0, 1);
draw->driver->quadric = gluNewQuadric();
}
int gf_draw_driver_has_extension(gf_draw_t* draw, const char* query) {
@ -154,8 +130,7 @@ int gf_draw_driver_has_extension(gf_draw_t* draw, const char* query) {
void gf_draw_driver_reshape(gf_draw_t* draw) {
glViewport(0, 0, (GLint)draw->width, (GLint)draw->height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(30, (double)draw->width / (double)draw->height, 1.0, 1000.0);
gf_graphic_perspective(draw, 30, 1.0, 1000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
@ -171,7 +146,7 @@ void gf_draw_driver_end_texture_2d(gf_draw_t* draw) {
glBindTexture(GL_TEXTURE_2D, 0);
}
void gf_draw_driver_set_color(gf_draw_t* draw, gf_color_t color) { glColor4f(color.r / 255, color.g / 255, color.b / 255, color.a / 255); }
void gf_draw_driver_set_color(gf_draw_t* draw, gf_graphic_color_t color) { glColor4f(color.r / 255, color.g / 255, color.b / 255, color.a / 255); }
void gf_draw_driver_destroy(gf_draw_t* draw) {
int i;
@ -182,12 +157,13 @@ void gf_draw_driver_destroy(gf_draw_t* draw) {
void gf_draw_driver_before(gf_draw_t* draw) {
GLfloat lightpos[4];
GF_VECTOR_COPY(draw->light, lightpos);
GF_MATH_VECTOR_COPY(draw->light, lightpos);
lightpos[3] = draw->light[3];
gf_draw_driver_reshape(draw);
gluLookAt(draw->camera[0], draw->camera[1], draw->camera[2], draw->lookat[0], draw->lookat[1], draw->lookat[2], 0, 1, 0);
gf_graphic_set_camera(draw);
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
gf_graphic_clear(draw);
}

63
engine/graphic/opengl/gf_graphic.c
View File

@ -13,9 +13,11 @@
#include <gf_draw.h>
#include <gf_texture.h>
#include <gf_draw_driver.h>
#include <gf_math.h>
/* Standard */
#include <stdarg.h>
#include <stdio.h>
void gf_graphic_begin_2d(gf_draw_t* draw) {
glDisable(GL_LIGHTING);
@ -41,7 +43,7 @@ void gf_graphic_end_2d(gf_draw_t* draw) {
void gf_graphic_clear(gf_draw_t* draw) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); }
void gf_graphic_draw_texture_polygon(gf_draw_t* draw, gf_texture_t* texture, gf_color_t color, int dim, int npair, ...) {
void gf_graphic_draw_texture_polygon(gf_draw_t* draw, gf_texture_t* texture, gf_graphic_color_t color, int dim, int npair, ...) {
double tw = (double)texture->width / texture->internal_width;
double th = (double)texture->height / texture->internal_height;
int i;
@ -76,7 +78,7 @@ void gf_graphic_draw_texture_polygon(gf_draw_t* draw, gf_texture_t* texture, gf_
va_end(va);
}
void gf_graphic_fill_polygon(gf_draw_t* draw, gf_color_t color, int dim, int npair, ...) {
void gf_graphic_fill_polygon(gf_draw_t* draw, gf_graphic_color_t color, int dim, int npair, ...) {
int i;
va_list va;
va_start(va, npair);
@ -102,3 +104,60 @@ void gf_graphic_fill_polygon(gf_draw_t* draw, gf_color_t color, int dim, int npa
va_end(va);
}
void gf_graphic_perspective(gf_draw_t* draw, double fovy, double znear, double zfar) {
double aspect = (double)draw->width / (double)draw->height;
double f = gf_math_cot(fovy / 180 * GF_MATH_PI / 2);
GLdouble matrix[16];
int i;
for(i = 0; i < 16; i++) matrix[i] = 0;
matrix[4 * 0 + 0] = f / aspect;
matrix[4 * 1 + 1] = f;
matrix[4 * 2 + 2] = (zfar + znear) / (znear - zfar);
matrix[4 * 3 + 2] = ((double)2 * zfar * znear) / (znear - zfar);
matrix[4 * 2 + 3] = -1;
glLoadIdentity();
glLoadMatrixd(matrix);
}
GF_EXPORT void gf_graphic_set_camera(gf_draw_t* draw) {
GLdouble matrix[16];
gf_math_vector_t f;
gf_math_vector_t up;
gf_math_vector_t s;
gf_math_vector_t u;
int i;
f[0] = draw->lookat[0] - draw->camera[0];
f[1] = draw->lookat[1] - draw->camera[1];
f[2] = draw->lookat[2] - draw->camera[2];
gf_math_normalize(f);
up[0] = 0;
up[1] = 1;
up[2] = 0;
gf_math_normalize(up);
gf_math_multiply(s, f, up);
gf_math_normalize(s);
gf_math_multiply(u, s, f);
for(i = 0; i < 16; i++) matrix[i] = 0;
matrix[4 * 0 + 0] = s[0];
matrix[4 * 1 + 0] = s[1];
matrix[4 * 2 + 0] = s[2];
matrix[4 * 0 + 1] = u[0];
matrix[4 * 1 + 1] = u[1];
matrix[4 * 2 + 1] = u[2];
matrix[4 * 0 + 2] = -f[0];
matrix[4 * 1 + 2] = -f[1];
matrix[4 * 2 + 2] = -f[2];
matrix[4 * 3 + 3] = 1;
glLoadIdentity();
glLoadMatrixd(matrix);
glTranslated(-draw->camera[0], -draw->camera[1], -draw->camera[2]);
}

2
engine/include/gf_draw_driver.h
View File

@ -92,7 +92,7 @@ GF_EXPORT void gf_draw_driver_end_texture_2d(gf_draw_t* draw);
* @param draw Drawing interface
* @param color Color
*/
GF_EXPORT void gf_draw_driver_set_color(gf_draw_t* draw, gf_color_t color);
GF_EXPORT void gf_draw_driver_set_color(gf_draw_t* draw, gf_graphic_color_t color);
/**
* @~english

29
engine/include/gf_graphic.h
View File

@ -46,7 +46,7 @@
/**
* @~english
* @brief Macro to set color safely and shorter
* @param color gf_color_t
* @param color gf_graphic_color_t
*/
#define GF_SET_COLOR(color, red, green, blue, alpha) \
color.r = (red); \
@ -76,13 +76,30 @@ GF_EXPORT void gf_graphic_end_2d(gf_draw_t* draw);
* @~english
* @brief Draw polygon with texture
*/
GF_EXPORT void gf_graphic_draw_texture_polygon(gf_draw_t* draw, gf_texture_t* texture, gf_color_t color, int dim, int npair, ...);
GF_EXPORT void gf_graphic_draw_texture_polygon(gf_draw_t* draw, gf_texture_t* texture, gf_graphic_color_t color, int dim, int npair, ...);
/**
* @~english
* @brief Draw polygon
*/
GF_EXPORT void gf_graphic_fill_polygon(gf_draw_t* draw, gf_color_t color, int dim, int npair, ...);
GF_EXPORT void gf_graphic_fill_polygon(gf_draw_t* draw, gf_graphic_color_t color, int dim, int npair, ...);
/**
* @~english
* @brief Set perspective
* @param draw Drawing interface
* @param fovy FOV
* @param znear Distance from viewer to the near clipping plane
* @param zfar Distance from viewer to the far clipping plane
*/
GF_EXPORT void gf_graphic_perspective(gf_draw_t* draw, double fovy, double znear, double zfar);
/**
* @~english
* @brief Set camera
* @param draw Drawing interface
*/
GF_EXPORT void gf_graphic_set_camera(gf_draw_t* draw);
/* Common */
@ -97,18 +114,18 @@ GF_EXPORT float gf_graphic_text_width(gf_draw_t* draw, float size, const char* t
* @~english
* @brief Draw text
*/
GF_EXPORT void gf_graphic_text(gf_draw_t* draw, float x, float y, float size, const char* text, gf_color_t color);
GF_EXPORT void gf_graphic_text(gf_draw_t* draw, float x, float y, float size, const char* text, gf_graphic_color_t color);
/**
* @~english
* @brief Draw filled rectangle
*/
GF_EXPORT void gf_graphic_fill_rect(gf_draw_t* draw, float x, float y, float w, float h, gf_color_t color);
GF_EXPORT void gf_graphic_fill_rect(gf_draw_t* draw, float x, float y, float w, float h, gf_graphic_color_t color);
/**
* @~english
* @brief Draw rectangle with texture
*/
GF_EXPORT void gf_graphic_draw_texture_2d(gf_draw_t* draw, float x, float y, float w, float h, gf_texture_t* texture, gf_color_t color);
GF_EXPORT void gf_graphic_draw_texture_2d(gf_draw_t* draw, float x, float y, float w, float h, gf_texture_t* texture, gf_graphic_color_t color);
#endif

44
engine/include/gf_math.h
View File

@ -17,13 +17,19 @@
/* Standard */
/**
* @~english
* @brief Pi
*/
#define GF_MATH_PI 3.14159265
/**
* @~english
* @brief Copy vector
* @param from Source
* @param to Destination
*/
#define GF_VECTOR_COPY(from, to) \
#define GF_MATH_VECTOR_COPY(from, to) \
to[0] = from[0]; \
to[1] = from[1]; \
to[2] = from[2]
@ -33,7 +39,7 @@
* @brief Calculate log2(x)
* @param x Input
*/
GF_EXPORT float gf_math_log2(float x);
GF_EXPORT double gf_math_log2(double x);
/**
* @~english
@ -43,6 +49,38 @@ GF_EXPORT float gf_math_log2(float x);
* @param v1 Input
* @param v2 Input
*/
GF_EXPORT void gf_math_normal(gf_vector_t* r, gf_vector_t v0, gf_vector_t v1, gf_vector_t v2);
GF_EXPORT void gf_math_normal(gf_math_vector_t r, gf_math_vector_t v0, gf_math_vector_t v1, gf_math_vector_t v2);
/**
* @~english
* @brief Calculate cot(x)
* @param x Input
*/
GF_EXPORT double gf_math_cot(double x);
/**
* @~english
* @brief Normalize vector
* @param v Input/Output
*/
GF_EXPORT void gf_math_normalize(gf_math_vector_t v);
/**
* @~english
* @brief Multiply vector by vector
* @param r Result
* @param v0 Input
* @param v1 Input
*/
GF_EXPORT void gf_math_multiply(gf_math_vector_t r, gf_math_vector_t v0, gf_math_vector_t v1);
/**
* @~english
* @brief Subtract vector by vector
* @param r Result
* @param v0 Input
* @param v1 Input
*/
GF_EXPORT void gf_math_subtract(gf_math_vector_t r, gf_math_vector_t v0, gf_math_vector_t v1);
#endif

1
engine/include/gf_opengl.h
View File

@ -12,7 +12,6 @@
#include <windows.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#if defined(USE_GLX)
#include <X11/Xlib.h>
#include <X11/Xatom.h>

6
engine/include/gf_type/draw.h
View File

@ -95,9 +95,9 @@ GF_DECLARE_TYPE(draw, {
int draw_3d;
char title[128];
gf_texture_t* font[128];
gf_vector_t light;
gf_vector_t lookat;
gf_vector_t camera;
gf_math_vector_t light;
gf_math_vector_t lookat;
gf_math_vector_t camera;
void (*draw)(gf_draw_t*);
});
#else

2
engine/include/gf_type/draw_driver.h
View File

@ -21,7 +21,7 @@
/* Standard */
#if defined(DRV_OPENGL)
GF_DECLARE_TYPE(draw_driver, { GLUquadric* quadric; });
GF_DECLARE_TYPE(draw_driver, { int unused; });
GF_DECLARE_TYPE(draw_driver_texture, {
GLuint id;
int width;

12
engine/include/gf_type/graphic.h
View File

@ -18,23 +18,23 @@
/* Standard */
/**
* @struct gf_color_t
* @struct gf_graphic_color_t
* @~english
* @brief Color
*
* @var gf_color_t::r
* @var gf_graphic_color_t::r
* @brief Red
*
* @var gf_color_t::g
* @var gf_graphic_color_t::g
* @brief Green
*
* @var gf_color_t::b
* @var gf_graphic_color_t::b
* @brief Blue
*
* @var gf_color_t::a
* @var gf_graphic_color_t::a
* @brief Alpha
*/
GF_DECLARE_TYPE(color, {
GF_DECLARE_TYPE(graphic_color, {
double r;
double g;
double b;

4
engine/include/gf_type/math.h
View File

@ -20,9 +20,9 @@
/**
* @~english
* @brief Vector
* @note gf_vector_t[3] is used internally
* @note gf_math_vector_t[3] is used internally
*/
typedef double gf_vector_t[4];
typedef double gf_math_vector_t[4];
#else
#error "should not happen!"
#endif

5
engine/include/gf_type/mesh.h
View File

@ -15,6 +15,7 @@
/* Engine */
#include <gf_type/math.h>
#include <gf_type/graphic.h>
/* Standard */
@ -30,8 +31,8 @@
* @brief Triangle color
*/
GF_DECLARE_TYPE(triangle, {
gf_vector_t points[3];
gf_vector_t color;
gf_math_vector_t points[3];
gf_graphic_color_t color;
});
/**

4
engine/premake5.lua
View File

@ -2,8 +2,8 @@ gf_backends = {
opengl = {
name = "OpenGL",
default = "glfw",
unix = {"GL", "GLU"},
windows = {"opengl32", "glu32"},
unix = {"GL"},
windows = {"opengl32"},
backends = {
glx = {"GLX", {"X11"}},
wgl = {"WGL", {"gdi32"}},