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

what am i doing

Browse source
This commit is contained in:
Nishi 2026-01-11 01:36:32 +09:00
commit 4cce33c16b
Signed by: nishi
GPG key ID: 27EF69B208EB9343
9 changed files with 196 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -18,11 +18,19 @@ GBDECL int GBGLTexturePrepare(GBGL gl, GLuint* texture, unsigned char* rgba, int
/* gl_shadow.c */
GBDECL void GBGLShadowInit(GBGL gl);
GBDECL void GBGLShadowBeforeMapping(GBGL gl);
GBDECL void GBGLShadowAfterMapping(GBGL gl);
GBDECL void GBGLShadowEnd(GBGL gl);
/* gl.c */
GBDECL GBGL GBGLCreate(GBClient client);
GBDECL void GBGLDestroy(GBGL gl);
/* gl_camera.c */
GBDECL void GBGLPerspective(GBGL gl, double width, double height);
GBDECL void GBGLSetCamera(GBGL gl);
GBDECL void GBGLLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at);
#ifdef __cplusplus
}
#endif

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

@ -75,8 +75,11 @@ struct _GBResourceKV {
struct _GBGL {
GBEngine engine;
GLuint shadow_texture;
GLuint shadow_shader;
GLuint shadow_texture;
GLuint shadow_shader;
GLdouble shadow_modelview[16];
GLdouble shadow_old_projection[16];
GLdouble shadow_old_modelview[16];
};
struct _GBClient {
@ -85,6 +88,7 @@ struct _GBClient {
GBGL gl;
GBVector3 look_at;
GBVector3 camera;
GBVector4 light0;
};
struct _GBServer {
@ -96,6 +100,8 @@ struct _GBEngine {
GBClient client;
GBServer server;
GBResourceKV* resource;
int width;
int height;
};
struct _GBFile {

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

@ -12,8 +12,9 @@ void main (void){
if(solid_color > 0.5){
c = color;
}else{
c = texture2D(current_texture, gl_TexCoord[1].st);
c = texture2D(current_texture, gl_TexCoord[0].st);
}
c = color;
gl_FragColor = (shadow + (gl_Color - shadow) * shadow2DProj(depth_texture, gl_TexCoord[0])) * c;
gl_FragColor = (shadow + (gl_Color - shadow) * shadow2DProj(depth_texture, gl_TexCoord[1])) * c;
}

4
engine/resource/shader/shadow.vs
View file

@ -22,7 +22,7 @@ void main(void){
gl_FrontColor += temp + gl_FrontLightProduct[0].specular * specular;
}
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_ModelViewMatrix * gl_Vertex;
gl_TexCoord[1] = gl_MultiTexCoord0;
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
gl_TexCoord[1] = gl_TextureMatrix[1] * gl_ModelViewMatrix * gl_Vertex;
gl_Position = ftransform();
}

77
engine/src/client.c
View file

@ -10,6 +10,19 @@ GBClient GBClientCreate(GBEngine engine) {
client->engine = engine;
client->camera[0] = 0;
client->camera[1] = 1.5;
client->camera[2] = 0;
client->look_at[0] = 0;
client->look_at[1] = 0;
client->look_at[2] = 0;
client->light0[0] = 0;
client->light0[1] = 1;
client->light0[2] = -5;
client->light0[3] = 1;
client->gl = GBGLCreate(client);
GBLog(GBLogInfo, "Created client");
@ -25,6 +38,66 @@ void GBClientDestroy(GBClient client) {
GBLog(GBLogInfo, "Destroyed client");
}
void GBClientStep(GBClient client) {
client->engine->param->gl_swapbuffer();
static void scene(void) {
glColor3f(1, 1, 1);
glBegin(GL_QUADS);
glNormal3f(0, 1, 0);
glVertex3f(-1, 0, -1);
glVertex3f(-1, 0, 1);
glVertex3f(1, 0, 1);
glVertex3f(1, 0, -1);
glEnd();
int i;
glColor3f(1, 0, 0);
for(i = 0; i < 2; i++) {
glPushMatrix();
glRotatef(180 * i, 0, 1, 0);
glBegin(GL_QUADS);
glNormal3f(-1, 0, 0);
glVertex3f(-1, 0.5, 0);
glVertex3f(-1, 0, 0);
glVertex3f(1, 0, 0);
glVertex3f(1, 0.5, 0);
glEnd();
glPopMatrix();
}
}
void GBClientStep(GBClient client) {
GLfloat f[4];
int i;
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);
GBGLShadowBeforeMapping(client->gl);
scene();
GBGLShadowAfterMapping(client->gl);
scene();
GBGLShadowEnd(client->gl);
client->engine->param->gl_swapbuffer();
static double r = 0;
client->camera[0] = cos(r) * 2;
client->camera[2] = sin(r) * 2;
// client->light0[0] = -cos(r) * 2;
// client->light0[2] = -sin(r) * 2;
r += 0.1;
}

7
engine/src/core.c
View file

@ -38,8 +38,11 @@ GBEngine GBEngineCreate(GBEngineParam* param) {
engine->param = malloc(sizeof(*engine->param));
memcpy(engine->param, param, sizeof(*param));
if(param->ready != NULL) {
param->ready(1024, 768);
engine->width = 1024;
engine->height = 768;
if(param->ready != NULL && param->client) {
param->ready(engine->width, engine->height);
}
sh_new_strdup(engine->resource);

4
engine/src/gl.c
View file

@ -1,7 +1,7 @@
#include <GearBox/GL.h>
GBGL GBGLCreate(GBClient client) {
GLfloat lightamb[] = {0.25, 0.25, 0.25, 1.0};
GLfloat lightamb[] = {0.5, 0.5, 0.5, 1.0};
GLfloat lightcol[] = {1.0, 1.0, 1.0, 1.0};
GBGL gl;
@ -35,4 +35,6 @@ GBGL GBGLCreate(GBClient client) {
}
void GBGLDestroy(GBGL gl) {
free(gl);
}

24
engine/src/gl_camera.c
View file

@ -2,16 +2,16 @@
#include <GearBox/Math.h>
void GBGLPerspective(GBGL gl, double fovy, double znear, double zfar) {
GLint vp[4];
void GBGLPerspective(GBGL gl, double width, double height) {
double aspect;
double f;
GLdouble matrix[16];
int i;
double fovy = 60.0;
double znear = 0.01;
double zfar = 10.0;
glGetIntegerv(GL_VIEWPORT, vp);
aspect = (double)vp[2] / vp[3];
aspect = width / height;
f = GBMathCot(fovy / 180 * GBMathPi / 2);
for(i = 0; i < 16; i++) matrix[i] = 0;
@ -21,11 +21,14 @@ void GBGLPerspective(GBGL gl, double fovy, double znear, double zfar) {
matrix[4 * 3 + 2] = ((double)2 * zfar * znear) / (znear - zfar);
matrix[4 * 2 + 3] = -1;
glLoadIdentity();
glLoadMatrixd(matrix);
glMultMatrixd(matrix);
}
void GBGLSetCamera(GBGL gl) {
GBGLLookAt(gl, gl->engine->client->camera, gl->engine->client->look_at);
}
void GBGLLookAt(GBGL gl, GBVector3 camera, GBVector3 look_at) {
GLdouble matrix[16];
GBVector3 f;
GBVector3 up;
@ -33,7 +36,7 @@ void GBGLSetCamera(GBGL gl) {
GBVector3 u;
int i;
GBMathSubtract3(f, gl->engine->client->look_at, gl->engine->client->camera);
GBMathSubtract3(f, look_at, camera);
GBMathNormalize3(f);
up[0] = 0;
@ -58,7 +61,6 @@ void GBGLSetCamera(GBGL gl) {
matrix[4 * 2 + 2] = -f[2];
matrix[4 * 3 + 3] = 1;
glLoadIdentity();
glLoadMatrixd(matrix);
glTranslated(-gl->engine->client->camera[0], -gl->engine->client->camera[1], -gl->engine->client->camera[2]);
glMultMatrixd(matrix);
glTranslated(-camera[0], -camera[1], -camera[2]);
}

82
engine/src/gl_shadow.c
View file

@ -24,7 +24,87 @@ void GBGLShadowInit(GBGL gl) {
if(GBGLShaderPrepare(gl, &gl->shadow_shader, "base:/shader/shadow.vs", "base:/shader/shadow.fs")) {
glUseProgram(gl->shadow_shader);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "shadow_texture"), 1);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "depth_texture"), 1);
glUniform1i(glGetUniformLocation(gl->shadow_shader, "current_texture"), 0);
}
}
void GBGLShadowBeforeMapping(GBGL gl) {
GBVector3 zero = {0, 0, 0};
glClear(GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
glMatrixMode(GL_PROJECTION);
glGetDoublev(GL_PROJECTION_MATRIX, gl->shadow_old_projection);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_old_modelview);
glLoadIdentity();
GBGLPerspective(gl, SHADOW_WIDTH, SHADOW_HEIGHT);
GBGLLookAt(gl, gl->engine->client->light0, zero);
glGetDoublev(GL_MODELVIEW_MATRIX, gl->shadow_modelview);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDisable(GL_LIGHTING);
glCullFace(GL_FRONT);
}
void GBGLShadowAfterMapping(GBGL gl) {
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
glViewport(0, 0, gl->engine->width, gl->engine->height);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glEnable(GL_LIGHTING);
glCullFace(GL_BACK);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMultMatrixd(gl->shadow_old_projection);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixd(gl->shadow_old_modelview);
glActiveTexture(GL_TEXTURE1);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glTranslated(0.5, 0.5, 0.5);
glScaled(0.5, 0.5, 0.5);
glMultMatrixd(gl->shadow_modelview);
glMultMatrixd(gl->shadow_old_modelview);
glActiveTexture(GL_TEXTURE0);
glMatrixMode(GL_MODELVIEW);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, gl->shadow_texture);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void GBGLShadowEnd(GBGL gl) {
glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE1);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glActiveTexture(GL_TEXTURE0);
glMatrixMode(GL_MODELVIEW);
}