pyrite-dev/assaultfish
13
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

use float instead of double

Browse source
This commit is contained in:
Nishi 2026-01-11 23:10:13 +09:00
commit e81666e657
Signed by: nishi
GPG key ID: 27EF69B208EB9343
10 changed files with 114 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

12
engine/include/GearBox/GL.h
View file

@ -22,15 +22,21 @@ GBDECL int GBGLShadowBeforeMapping(GBGL gl);
GBDECL void GBGLShadowAfterMapping(GBGL gl); GBDECL void GBGLShadowAfterMapping(GBGL gl);
GBDECL void GBGLShadowEnd(GBGL gl); GBDECL void GBGLShadowEnd(GBGL gl);
GBDECL void GBGLShadowDeinit(GBGL gl); GBDECL void GBGLShadowDeinit(GBGL gl);
GBDECL void GBGLShadowDisable(GBGL gl);
GBDECL void GBGLShadowEnable(GBGL gl);
/* gl.c */ /* gl.c */
GBDECL GBGL GBGLCreate(GBClient client); GBDECL GBGL GBGLCreate(GBClient client);
GBDECL void GBGLDestroy(GBGL gl); GBDECL void GBGLDestroy(GBGL gl);
GBDECL void GBGLClear(GBGL gl);
GBDECL void GBGLIgnoreDepth(GBGL gl);
GBDECL void GBGLCareDepth(GBGL gl);
/* gl_camera.c */ /* gl_camera.c */
GBDECL void GBGLPerspective(GBGL gl, double width, double height); GBDECL void GBGLCameraPerspective(GBGL gl, GBNumber width, GBNumber height);
GBDECL void GBGLSetCamera(GBGL gl); GBDECL void GBGLCameraSet(GBGL gl);
GBDECL void GBGLLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at); GBDECL void GBGLCameraLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at);
GBDECL void GBGLCameraSetup(GBGL gl);
#ifdef __cplusplus #ifdef __cplusplus
} }

16
engine/include/GearBox/Math.h
View file

@ -10,14 +10,14 @@ extern "C" {
#define GBMathPi 3.14159265358979323846 #define GBMathPi 3.14159265358979323846
GBDECL void GBMathCross3(GBVector3 r, GBVector3 v0, GBVector3 v1); GBDECL void GBMathCross3(GBVector3 r, GBVector3 v0, GBVector3 v1);
GBDECL void GBMathNormalize3(GBVector3 vec); GBDECL void GBMathNormalize3(GBVector3 vec);
GBDECL void GBMathSubtract3(GBVector3 r, GBVector3 v0, GBVector3 v1); GBDECL void GBMathSubtract3(GBVector3 r, GBVector3 v0, GBVector3 v1);
GBDECL void GBMathAdd3(GBVector3 r, GBVector3 v0, GBVector3 v1); GBDECL void GBMathAdd3(GBVector3 r, GBVector3 v0, GBVector3 v1);
GBDECL void GBMathNormal3x3(GBVector3 r, GBVector3 v0, GBVector3 v1, GBVector3 v2); GBDECL void GBMathNormal3x3(GBVector3 r, GBVector3 v0, GBVector3 v1, GBVector3 v2);
GBDECL void GBMathNormal3x4(GBVector3 r, GBVector3 v0, GBVector3 v1, GBVector3 v2, GBVector3 v3); GBDECL void GBMathNormal3x4(GBVector3 r, GBVector3 v0, GBVector3 v1, GBVector3 v2, GBVector3 v3);
GBDECL void GBMathInvert4x4(GBMatrix4x4 out, GBMatrix4x4 in); GBDECL void GBMathInvert4x4(GBMatrix4x4 out, GBMatrix4x4 in);
GBDECL double GBMathCot(double x); GBDECL GBNumber GBMathCot(GBNumber x);
#ifdef __cplusplus #ifdef __cplusplus
} }

7
engine/include/GearBox/TypeDefs.h
View file

@ -55,9 +55,10 @@ typedef void* GBFile;
typedef void* GBResource; typedef void* GBResource;
typedef void* GBGL; typedef void* GBGL;
#endif #endif
typedef double GBVector3[3]; typedef float GBNumber;
typedef double GBVector4[4]; typedef GBNumber GBVector3[3];
typedef double GBMatrix4x4[16]; typedef GBNumber GBVector4[4];
typedef GBNumber GBMatrix4x4[16];
typedef void (*GBGLSwapBufferCallback)(void); typedef void (*GBGLSwapBufferCallback)(void);
typedef void (*GBReadyCallback)(int width, int height); typedef void (*GBReadyCallback)(int width, int height);

6
engine/net/include/gbnet.h
View file

@ -5,14 +5,18 @@
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
#include <unistd.h>
#include <sys/types.h> #include <sys/types.h>
#ifdef _WIN32
#include <winsock2.h>
#else
#include <unistd.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netdb.h> #include <netdb.h>
#include <netinet/tcp.h> #include <netinet/tcp.h>
#include <poll.h> #include <poll.h>
#endif
/* TCP */ /* TCP */
#define NET_PORT 3219 #define NET_PORT 3219

3
engine/resource/shader/shadow.fs
View file

@ -6,6 +6,7 @@ varying vec4 vShadowCoord;
uniform sampler2D depth_texture; uniform sampler2D depth_texture;
uniform sampler2D current_texture; uniform sampler2D current_texture;
uniform float enable_lighting;
vec4 PhongShading(void) vec4 PhongShading(void)
{ {
@ -61,7 +62,7 @@ float ShadowCoef(void){
} }
void main(void){ void main(void){
vec4 c = PhongShading(); vec4 c = enable_lighting > 0.5 ? PhongShading() : gl_Color;
vec4 ambient = gl_LightSource[0].ambient; vec4 ambient = gl_LightSource[0].ambient;
float shadow_coef = ShadowCoef(); float shadow_coef = ShadowCoef();

80
engine/src/client.c
View file

@ -41,90 +41,26 @@ void GBClientDestroy(GBClient client) {
static double r = 0; static double r = 0;
static void scene(void) { static void scene(GBClient client) {
glColor3f(1, 1, 1);
int i;
double u = 1;
glPushMatrix();
glTranslatef(0, fabs(sin(r)), 1);
glBegin(GL_QUADS);
glNormal3f(0, -1, 0);
for(i = 0; i < 4; i++) {
glVertex3f(cos(90 * i / 180.0 * GBMathPi), u, sin(90 * i / 180.0 * GBMathPi));
}
glEnd();
for(i = 0; i < 4; i++) {
double n[3];
double v0[3];
double v1[3];
double v2[3];
v0[0] = 0;
v0[1] = 1 + u;
v0[2] = 0;
v1[0] = cos(90 * (i + 1) / 180.0 * GBMathPi);
v1[1] = u;
v1[2] = sin(90 * (i + 1) / 180.0 * GBMathPi);
v2[0] = cos(90 * i / 180.0 * GBMathPi);
v2[1] = u;
v2[2] = sin(90 * i / 180.0 * GBMathPi);
GBMathNormal3x3(n, v0, v1, v2);
glBegin(GL_TRIANGLES);
glNormal3f(n[0], n[1], n[2]);
glVertex3f(v0[0], v0[1], v0[2]);
glVertex3f(v1[0], v1[1], v1[2]);
glVertex3f(v2[0], v2[1], v2[2]);
glEnd();
}
glPopMatrix();
} }
void GBClientStep(GBClient client) { void GBClientStep(GBClient client) {
GLfloat f[4]; GBGLClear(client->gl);
int i; GBGLCameraSetup(client->gl);
GBGLSetLight(client->gl);
for(i = 0; i < 4; i++) f[i] = client->light0[i];
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
GBGLPerspective(client->gl, client->engine->width, client->engine->height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GBGLSetCamera(client->gl);
glLightfv(GL_LIGHT0, GL_POSITION, f);
if(GBGLShadowBeforeMapping(client->gl)) { if(GBGLShadowBeforeMapping(client->gl)) {
scene(); scene(client);
GBGLShadowAfterMapping(client->gl); GBGLShadowAfterMapping(client->gl);
} }
glDisable(GL_DEPTH_TEST); scene(client);
glBegin(GL_QUADS);
glNormal3f(0, 1, 0);
glVertex3f(-10, -0, -10);
glVertex3f(-10, -0, 10);
glVertex3f(10, -0, 10);
glVertex3f(10, -0, -10);
glEnd();
glEnable(GL_DEPTH_TEST);
scene();
GBGLShadowEnd(client->gl); GBGLShadowEnd(client->gl);
client->engine->param->gl_swapbuffer(); client->engine->param->gl_swapbuffer();
client->light0[0] = cos(r) * 5; client->camera[0] = cos(r) * 5;
client->light0[2] = sin(r) * 5; client->camera[2] = sin(r) * 5;
r += 0.1; r += 0.1;
} }

21
engine/src/gl.c
View file

@ -39,3 +39,24 @@ void GBGLDestroy(GBGL gl) {
free(gl); free(gl);
} }
void GBGLClear(GBGL gl) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void GBGLIgnoreDepth(GBGL gl) {
glDisable(GL_DEPTH_TEST);
}
void GBGLCareDepth(GBGL gl) {
glEnable(GL_DEPTH_TEST);
}
void GBGLSetLight(GBGL gl) {
GLfloat f[4];
int i;
for(i = 0; i < 4; i++) f[i] = gl->engine->client->light0[i];
glLightfv(GL_LIGHT0, GL_POSITION, f);
}

30
engine/src/gl_camera.c
View file

@ -2,14 +2,14 @@
#include <GearBox/Math.h> #include <GearBox/Math.h>
void GBGLPerspective(GBGL gl, double width, double height) { void GBGLCameraPerspective(GBGL gl, GBNumber width, GBNumber height) {
double aspect; GBNumber aspect;
double f; GBNumber f;
GLdouble matrix[16]; GLdouble matrix[16];
int i; int i;
double fovy = 60.0; GBNumber fovy = 60.0;
double znear = 0.01; GBNumber znear = 0.01;
double zfar = 100.0; GBNumber zfar = 100.0;
aspect = width / height; aspect = width / height;
f = GBMathCot(fovy / 180 * GBMathPi / 2); f = GBMathCot(fovy / 180 * GBMathPi / 2);
@ -18,17 +18,17 @@ void GBGLPerspective(GBGL gl, double width, double height) {
matrix[4 * 0 + 0] = f / aspect; matrix[4 * 0 + 0] = f / aspect;
matrix[4 * 1 + 1] = f; matrix[4 * 1 + 1] = f;
matrix[4 * 2 + 2] = (zfar + znear) / (znear - zfar); matrix[4 * 2 + 2] = (zfar + znear) / (znear - zfar);
matrix[4 * 3 + 2] = ((double)2 * zfar * znear) / (znear - zfar); matrix[4 * 3 + 2] = ((GLdouble)2 * zfar * znear) / (znear - zfar);
matrix[4 * 2 + 3] = -1; matrix[4 * 2 + 3] = -1;
glMultMatrixd(matrix); glMultMatrixd(matrix);
} }
void GBGLSetCamera(GBGL gl) { void GBGLCameraSet(GBGL gl) {
GBGLLookAt(gl, gl->engine->client->camera, gl->engine->client->look_at); GBGLCameraLookAt(gl, gl->engine->client->camera, gl->engine->client->look_at);
} }
void GBGLLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at) { void GBGLCameraLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at) {
GLdouble matrix[16]; GLdouble matrix[16];
GBVector3 f; GBVector3 f;
GBVector3 up; GBVector3 up;
@ -64,3 +64,13 @@ void GBGLLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at) {
glMultMatrixd(matrix); glMultMatrixd(matrix);
glTranslated(-camera[0], -camera[1], -camera[2]); glTranslated(-camera[0], -camera[1], -camera[2]);
} }
void GBGLCameraSetup(GBGL gl) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
GBGLCameraPerspective(gl, gl->engine->width, gl->engine->height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GBGLCameraSet(gl);
}

40
engine/src/gl_shadow.c
View file

@ -29,6 +29,7 @@ void GBGLShadowInit(GBGL gl) {
glUseProgram(gl->shadow_shader); glUseProgram(gl->shadow_shader);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "depth_texture"), 7); glUniform1i(glGetUniformLocation(gl->shadow_shader, "depth_texture"), 7);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "current_texture"), 0); glUniform1i(glGetUniformLocation(gl->shadow_shader, "current_texture"), 0);
glUniform1f(glGetUniformLocation(gl->shadow_shader, "enable_lighting"), 1);
glUseProgram(0); glUseProgram(0);
gl->shadow_use_shader = 1; gl->shadow_use_shader = 1;
@ -44,21 +45,21 @@ int GBGLShadowBeforeMapping(GBGL gl) {
if(!gl->shadow_use_shader) return 0; if(!gl->shadow_use_shader) return 0;
glClear(GL_DEPTH_BUFFER_BIT); GBGLClear(gl);
glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT); glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_old_projection); glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_old_projection);
glLoadIdentity(); glLoadIdentity();
GBGLPerspective(gl, SHADOW_WIDTH, SHADOW_HEIGHT); GBGLCameraPerspective(gl, SHADOW_WIDTH, SHADOW_HEIGHT);
glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_projection); glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_projection);
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_old_modelview); glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_old_modelview);
glLoadIdentity(); glLoadIdentity();
GBGLLookAt(gl, gl->engine->client->light0, zero); GBGLCameraLookAt(gl, gl->engine->client->light0, zero);
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_modelview); glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_modelview);
@ -125,20 +126,39 @@ void GBGLShadowAfterMapping(GBGL gl) {
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glActiveTexture(GL_TEXTURE7); GBGLClear(gl);
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GBGLShadowEnable(gl);
}
glUseProgram(gl->shadow_shader); void GBGLShadowDisable(GBGL gl) {
glDisable(GL_LIGHTING);
if(gl->shadow_use_shader) {
glUseProgram(0);
glActiveTexture(GL_TEXTURE7);
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
}
}
void GBGLShadowEnable(GBGL gl) {
glEnable(GL_LIGHTING);
if(gl->shadow_use_shader) {
glUseProgram(gl->shadow_shader);
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
}
} }
void GBGLShadowEnd(GBGL gl) { void GBGLShadowEnd(GBGL gl) {
if(!gl->shadow_use_shader) return; if(!gl->shadow_use_shader) return;
glUseProgram(0); GBGLShadowDisable(gl);
glActiveTexture(GL_TEXTURE7); glActiveTexture(GL_TEXTURE7);
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);

14
engine/src/math.c
View file

@ -7,15 +7,15 @@ void GBMathCross3(GBVector3 r, GBVector3 v0, GBVector3 v1) {
} }
void GBMathNormalize3(GBVector3 vec) { void GBMathNormalize3(GBVector3 vec) {
double l = 0; GBNumber l = 0;
int i; int i;
for(i = 0; i < 3; i++) l += vec[i] * vec[i]; for(i = 0; i < 3; i++) l += vec[i] * vec[i];
l = sqrt(l); l = sqrt(l);
if(l > 0) { if(l > 0) {
l = (double)1 / l; l = (GBNumber)1 / l;
} else { } else {
l = 0; l = 0;
} }
@ -69,13 +69,13 @@ void GBMathNormal3x4(GBVector3 r, GBVector3 v0, GBVector3 v1, GBVector3 v2, GBVe
GBMathNormalize3(r); GBMathNormalize3(r);
} }
double GBMathCot(double x) { GBNumber GBMathCot(GBNumber x) {
return (double)1 / tan(x); return (GBNumber)1 / tan(x);
} }
void GBMathInvert4x4(GBMatrix4x4 out, GBMatrix4x4 in) { void GBMathInvert4x4(GBMatrix4x4 out, GBMatrix4x4 in) {
double inv[16], det; GBNumber inv[16], det;
int i; int i;
inv[0] = in[5] * in[10] * in[15] - in[5] * in[11] * in[14] - in[9] * in[6] * in[15] + in[9] * in[7] * in[14] + in[13] * in[6] * in[11] - in[13] * in[7] * in[10]; inv[0] = in[5] * in[10] * in[15] - in[5] * in[11] * in[14] - in[9] * in[6] * in[15] + in[9] * in[7] * in[14] + in[13] * in[6] * in[11] - in[13] * in[7] * in[10];
inv[4] = -in[4] * in[10] * in[15] + in[4] * in[11] * in[14] + in[8] * in[6] * in[15] - in[8] * in[7] * in[14] - in[12] * in[6] * in[11] + in[12] * in[7] * in[10]; inv[4] = -in[4] * in[10] * in[15] + in[4] * in[11] * in[14] + in[8] * in[6] * in[15] - in[8] * in[7] * in[14] - in[12] * in[6] * in[11] + in[12] * in[7] * in[10];