diff --git a/src/gl/render.c b/src/gl/render.c
index 01e40146833ca4d31835c113e65c8cf0d0b3b7c4..426f43ccc1eb7ce1cf5d53723721cfe66bc5dacb 100644 (file)
--- a/src/gl/render.c
+++ b/src/gl/render.c
#include "glob.h"
#include "render.h"
+#include "system.h"
#include "files.h"
#include "memory.h"
#include "misc.h"
#include "view.h"
#include "switch.h" // sw_secrets
-#include <OpenGL/GL.h>
-#include <stdlib.h> // malloc free abs
-#include <assert.h> // assert
-#include <SDL.h>
+#ifdef __APPLE__
+# include <OpenGL/gl.h>
+#else
+# include <GL/gl.h>
+#endif
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
#define VGA_TRANSPARENT_COLOR 0
#define DEFAULT_SKY_COLOR 0x97
} rgba;
#pragma pack()
-typedef struct image {
+typedef struct node {
+ struct cache *base;
+ struct node *left, *right;
+ struct node *up;
+ int l, t, r, b;
+ int leaf;
+} node;
+
+typedef struct cache {
+ struct cache *next;
+ struct node root;
GLuint id;
+} cache;
+
+typedef struct image {
+ node *n;
GLint x, y;
GLuint w, h;
int res;
int SCRH = 200; // public
static int gamma;
static int fullscreen;
-static SDL_Surface *surf;
static rgb playpal[256];
static byte bright[256];
+static GLuint lastTexture;
+static cache *root;
/* Game */
static image scrnh[3]; // TITLEPIC INTERPIC ENDPIC
static byte anic[ANIT];
static image horiz;
+/* Texture cache */
+
+// https://blackpawn.com/texts/lightmaps/
+static node *R_node_alloc (node *p, int w, int h) {
+ assert(p);
+ assert(w > 0);
+ assert(h > 0);
+ if (p->left) {
+ assert(p->right);
+ node *n = R_node_alloc(p->left, w, h);
+ return n ? n : R_node_alloc(p->right, w, h);
+ } else {
+ int pw = p->r - p->l + 1;
+ int ph = p->b - p->t + 1;
+ if (p->leaf || pw < w || ph < h) {
+ return NULL;
+ } else if (pw == w && ph == h) {
+ p->leaf = 1;
+ return p;
+ } else {
+ p->left = malloc(sizeof(node));
+ p->right = malloc(sizeof(node));
+ if (pw - w > ph - h) {
+ *p->left = (node) {
+ .up = p,
+ .l = p->l,
+ .t = p->t,
+ .r = p->l + w - 1,
+ .b = p->b
+ };
+ *p->right = (node) {
+ .up = p,
+ .l = p->l + w,
+ .t = p->t,
+ .r = p->r,
+ .b = p->b
+ };
+ } else {
+ *p->left = (node) {
+ .up = p,
+ .l = p->l,
+ .t = p->t,
+ .r = p->r,
+ .b = p->t + h - 1
+ };
+ *p->right = (node) {
+ .up = p,
+ .l = p->l,
+ .t = p->t + h,
+ .r = p->r,
+ .b = p->b
+ };
+ }
+ return R_node_alloc(p->left, w, h);
+ }
+ }
+}
+
+static int R_node_have_leaf (node *n) {
+ return n && (n->leaf || R_node_have_leaf(n->left) || R_node_have_leaf(n->right));
+}
+
+static void R_node_free_recursive (node *n) {
+ if (n) {
+ R_node_free_recursive(n->left);
+ R_node_free_recursive(n->right);
+ free(n);
+ }
+}
+
+static void R_node_free (node *n) {
+ if (n) {
+ //logo("free node %p {%i:%i:%i:%i}\n", n, n->l, n->t, n->r, n->b);
+ assert(n->leaf);
+ assert(n->left == NULL);
+ assert(n->right == NULL);
+ n->leaf = 0;
+ n->base = NULL;
+ node *p = n->up;
+ while (p != NULL) {
+ assert(p->leaf == 0);
+ assert(p->left);
+ assert(p->right);
+ if (R_node_have_leaf(p) == 0) {
+ R_node_free_recursive(p->left);
+ p->left = NULL;
+ R_node_free_recursive(p->right);
+ p->right = NULL;
+ p = p->up;
+ } else {
+ p = NULL;
+ }
+ }
+ }
+}
+
+static void R_cache_get_max_texture_size (int *w, int *h) {
+ GLint size = 0;
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size);
+ size = min(max(size, 0), 512); // more can be buggy on older hardware
+ *w = size;
+ *h = size;
+}
+
+static void R_gl_bind_texture (GLuint id) {
+ if (id != lastTexture) {
+ glBindTexture(GL_TEXTURE_2D, id);
+ }
+}
+
+static cache *R_cache_new (void) {
+ int w, h;
+ GLuint id;
+ cache *c = NULL;
+ R_cache_get_max_texture_size(&w, &h);
+ if (w && h) {
+ glGenTextures(1, &id);
+ if (id) {
+ R_gl_bind_texture(id);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ c = malloc(sizeof(cache));
+ if (c != NULL) {
+ *c = (cache) {
+ .id = id,
+ .root.r = w - 1,
+ .root.b = h - 1
+ };
+ } else {
+ glDeleteTextures(1, &id);
+ }
+ }
+ }
+ //logo("new cache %p\n", c);
+ return c;
+}
+
+static void R_cache_free (cache *root, int freetexture) {
+ cache *next;
+ cache *c = root;
+ while (c != NULL) {
+ next = c->next;
+ R_node_free_recursive(c->root.left);
+ R_node_free_recursive(c->root.right);
+ if (freetexture && c->id != 0) {
+ glDeleteTextures(1, &c->id);
+ }
+ free(c);
+ c = next;
+ }
+}
+
+static node *R_cache_alloc (cache *root, int w, int h) {
+ assert(root);
+ assert(w > 0 && h > 0);
+ node *n = NULL;
+ cache *p = NULL;
+ cache *c = root;
+ int maxw, maxh;
+ R_cache_get_max_texture_size(&maxw, &maxh);
+ if (w <= maxw && h <= maxh) {
+ while (c && !n) {
+ n = R_node_alloc(&c->root, w, h);
+ if (n) {
+ assert(n->leaf);
+ n->base = c;
+ }
+ p = c;
+ c = c->next;
+ }
+ if (!n) {
+ c = R_cache_new();
+ if (c) {
+ p->next = c;
+ n = R_node_alloc(&c->root, w, h);
+ if (n) {
+ assert(n->leaf);
+ n->base = c;
+ }
+ }
+ }
+ }
+ if (n) {
+ //logo("new node %p {%i:%i:%i:%i}\n", n, n->l, n->t, n->r, n->b);
+ } else {
+ logo("new node failed {%i:%i}\n", w, h);
+ }
+ return n;
+}
+
+static void R_cache_update (node *n, const void *data, int x, int y, int w, int h) {
+ assert(n);
+ assert(n->leaf);
+ assert(n->base);
+ assert(data);
+ assert(x >= 0);
+ assert(y >= 0);
+ assert(n->l + x + w - 1 <= n->r);
+ assert(n->t + y + h - 1 <= n->b);
+ R_gl_bind_texture(n->base->id);
+ glTexSubImage2D(GL_TEXTURE_2D, 0, n->l + x, n->t + y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
+}
+
/* Generic helpers */
static void R_init_playpal (void) {
/* OpenGL helpers */
static image R_gl_create_image (const rgba *buf, int w, int h) {
- GLuint tex = 0;
- glGenTextures(1, &tex);
- if (tex != 0) {
- glBindTexture(GL_TEXTURE_2D, tex);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
- glBindTexture(GL_TEXTURE_2D, 0);
+ node *n = R_cache_alloc(root, w, h);
+ if (n) {
+ R_cache_update(n, buf, 0, 0, w, h);
}
return (image) {
- .id = tex,
+ .n = n,
.w = w,
.h = h,
+ .res = -1
};
}
static image R_gl_get_special_image (int id, rgba *(*fn)(vgaimg*)) {
- image img = (image) { .res = -1 };
+ image img;
+ //char name[8];
+ //F_getresname(name, id);
+ //logo("load image: %.8s\n", name);
vgaimg *v = R_getvga(id);
if (v != NULL) {
rgba *buf = (*fn)(v);
img.res = id;
M_unlock(v);
free(buf);
+ } else {
+ img = (image) {
+ .res = id
+ };
}
return img;
}
@@ -309,10 +537,11 @@ static image R_gl_get_special_spr (const char n[4], int s, int d, rgba *(*fn)(vg
}
static void R_gl_free_image (image *img) {
- if (img->id != 0 && img->res >= 0) {
- glDeleteTextures(1, &img->id);
+ if (img->n != NULL && img->res >= 0) {
+ R_node_free(img->n);
}
- img->id = 0;
+ img->n = NULL;
+ img->res = -1;
}
static void R_gl_draw_quad (int x, int y, int w, int h) {
}
static void R_gl_draw_textured (image *img, int x, int y, int w, int h, int flip) {
- int ax = flip == 0;
- int bx = !ax;
- glBindTexture(GL_TEXTURE_2D, img->id);
- glEnable(GL_TEXTURE_2D);
- glBegin(GL_QUADS);
- glTexCoord2f(ax, 0); glVertex2i(x + w, y);
- glTexCoord2f(bx, 0); glVertex2i(x, y);
- glTexCoord2f(bx, 1); glVertex2i(x, y + h);
- glTexCoord2f(ax, 1); glVertex2i(x + w, y + h);
- glEnd();
- glDisable(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D, 0);
+ if (img->n) {
+ GLfloat nw = img->n->base->root.r + 1;
+ GLfloat nh = img->n->base->root.b + 1;
+ GLfloat ax = (flip ? img->n->l : img->n->r + 1) / nw;
+ GLfloat bx = (flip ? img->n->r + 1 : img->n->l) / nh;
+ GLfloat ay = (img->n->t) / nw;
+ GLfloat by = (img->n->b + 1) / nh;
+ R_gl_bind_texture(img->n->base->id);
+ glEnable(GL_TEXTURE_2D);
+ glBegin(GL_QUADS);
+ glTexCoord2f(ax, ay); glVertex2i(x + w, y);
+ glTexCoord2f(bx, ay); glVertex2i(x, y);
+ glTexCoord2f(bx, by); glVertex2i(x, y + h);
+ glTexCoord2f(ax, by); glVertex2i(x + w, y + h);
+ glEnd();
+ } else {
+ glColor3ub(255, 0, 0);
+ glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
+ R_gl_draw_quad(x, y, w, h);
+ }
}
/* fit image into rectangle without applying offset and transparency */
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
R_gl_draw_textured(img, xx, y - img->y, img->w, img->h, flip);
- glDisable(GL_BLEND);
}
/* draw sprite with offset */
static void R_gl_draw_image (image *img, int x, int y, int flip) {
- int xx = flip ? x - img->w + img->x : x - img->x;
- glEnable(GL_BLEND);
glColor3ub(255, 255, 255);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- R_gl_draw_textured(img, xx, y - img->y, img->w, img->h, flip);
+ R_gl_draw_image_color(img, x, y, flip);
}
static void R_gl_set_color (byte c) {
@@ -599,7 +834,7 @@ static void R_draw_fld (byte *fld, int minx, int miny, int maxx, int maxy, int f
if (id != 0) {
if (walp[id].res < 0) {
if (fg) {
- switch (walp[id].id) {
+ switch (R_get_special_id(id)) {
case 1:
glColor4ub(0, 0, 255, 127);
break;
@@ -615,6 +850,7 @@ static void R_draw_fld (byte *fld, int minx, int miny, int maxx, int maxy, int f
}
glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
+ glDisable(GL_TEXTURE_2D);
R_gl_draw_quad(i * CELW, j * CELW, CELW, CELH);
}
} else {
@@ -627,6 +863,9 @@ static void R_draw_fld (byte *fld, int minx, int miny, int maxx, int maxy, int f
static void R_draw_dots (void) {
int i;
+ glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
glBegin(GL_POINTS);
for (i = 0; i < MAXDOT; i++) {
if (dot[i].t != 0) {
R_gl_draw_image(&fx_spr[s], fx[i].x, fx[i].y, fx_sprd[s]);
break;
case BUBL:
+ glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
glBegin(GL_POINTS);
R_gl_set_color(0xC0 + fx[i].s);
glVertex2i(fx[i].x >> 8, (fx[i].y >> 8) + 1);
glPushMatrix();
R_gl_setclip(x, y, w, h);
glTranslatef(x, y, 0);
- if (w_horiz && horiz.id != 0) {
+ if (w_horiz && horiz.n != NULL) {
R_gl_draw_image_ext(&horiz, 0, 0, w, h);
if (sky_type == 2 && lt_time < 0) {
image *tanderbolt = <n[lt_type][lt_time < -5 ? 0 : 1];
}
} else {
glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
R_gl_set_color(DEFAULT_SKY_COLOR);
R_gl_draw_quad(0, 0, w, h);
}
glColor4ub(255, 255, 255, 255);
glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
+ glDisable(GL_TEXTURE_2D);
R_gl_draw_quad(0, 0, w, h);
}
glPopMatrix();
if (p->invl) {
if (get_pu_st(p->invl)) {
glEnable(GL_BLEND);
- glColor4ub(191, 191, 191, 255);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
+ glDisable(GL_TEXTURE_2D);
+ glColor4ub(191, 191, 191, 255);
R_gl_draw_quad(0, 0, cw, h);
}
} else {
if (p->suit && get_pu_st(p->suit)) {
glEnable(GL_BLEND);
- glColor4ub(0, 255, 0, 192);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
+ glColor4ub(0, 255, 0, 192);
R_gl_draw_quad(0, 0, cw, h);
}
int f = min(max(p->pain * 3, 0), 255);
if (f > 0) {
glEnable(GL_BLEND);
- glColor4ub(255, 0, 0, f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
+ glColor4ub(255, 0, 0, f);
R_gl_draw_quad(0, 0, cw, h);
}
}
if (p->air < PL_AIR) {
int a = min(max(p->air, 0), MAXAIR) * 100 / MAXAIR;
glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
R_gl_set_color(0xC8);
R_gl_draw_quad(10, 49, a, 2);
}
void R_draw (void) {
W_act();
glClearColor(0, 0, 0, 1);
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ glClear(GL_COLOR_BUFFER_BIT);
glEnable(GL_SCISSOR_TEST);
R_gl_setmatrix();
switch (g_st) {
break;
}
GM_draw();
- SDL_GL_SwapBuffers();
+ Y_swap_buffers();
}
void R_alloc (void) {
mslotr = R_gl_loadimage("M_LSRGHT");
// walls
for (i = 1; i < ANIT; i++) {
- for (j = 0; anm[i - 1][j]; j++) {
+ for (j = 0; j < 5 && anm[i - 1][j]; j++) {
anip[i][j] = R_gl_loadimage(anm[i - 1][j]);
}
for(; j < 5; j++) {
anip[i][j] = (image) {
+ .n = NULL,
.w = 8,
.h = 8,
.res = -1,
}
}
-void R_init (void) {
- Uint32 flags = SDL_OPENGL;
+static void R_reload_textures (void);
+
+void R_set_videomode (int w, int h, int fullscreen) {
+ assert(w > 0);
+ assert(h > 0);
+ int was = Y_videomode_setted();
+ int flags = SYSTEM_USE_OPENGL;
if (fullscreen) {
- flags = flags | SDL_FULLSCREEN;
+ flags |= SYSTEM_USE_FULLSCREEN;
}
- if (SCRW <= 0 || SCRH <= 0) {
- ERR_failinit("Invalid screen size %ix%i\n", SCRW, SCRH);
+ if (root != NULL) {
+ R_cache_free(root, 0);
+ root = NULL;
}
- if (surf == NULL) {
- R_init_playpal(); // only onece
- }
- surf = SDL_SetVideoMode(SCRW, SCRH, 0, flags);
- if (surf == NULL) {
- ERR_failinit("Unable to set video mode: %s\n", SDL_GetError());
+ int res = Y_set_videomode(w, h, flags);
+ if (res == 0) {
+ if (was == 0) {
+ ERR_failinit("Unable to set video mode\n");
+ }
+ } else {
+ Y_get_videomode(&SCRW, &SCRH);
+ root = R_cache_new();
+ assert(root);
+ R_alloc();
+ R_reload_textures();
}
+}
+
+void R_toggle_fullscreen (void) {
+ R_cache_free(root, 0);
+ Y_set_fullscreen(!Y_get_fullscreen());
+ fullscreen = Y_get_fullscreen();
+ Y_get_videomode(&SCRW, &SCRH);
+ root = R_cache_new();
+ assert(root);
R_alloc();
+ R_reload_textures();
+}
+
+void R_init (void) {
+ logo("R_init: intialize opengl render\n");
+ R_init_playpal();
+ R_set_videomode(SCRW, SCRH, fullscreen);
}
void R_done (void) {
- // do nothing
+ R_cache_free(root, 1);
+ Y_unset_videomode();
+ root = NULL;
}
void R_setgamma (int g) {
return gamma;
}
-void R_toggle_fullscreen (void) {
- fullscreen = !fullscreen;
- if (surf) {
- R_init(); // recreate window
- }
-}
-
void R_get_name (int n, char s[8]) {
assert(n >= 0 && n < 256);
if (walp[n].res == -1) {
memset(s, 0, 8);
} else if (walp[n].res == -2) {
memcpy(s, "_WATER_", 8);
- s[7] = '0' + walp[n].id - 1;
+ s[7] = '0' + (intptr_t)walp[n].n - 1;
} else if (walani[n] > 0) {
memcpy(s, anm[walani[n] - 1][0], 8);
} else {
static short getani (char n[8]) {
short i = 0;
- while (i < ANIT && strncasecmp(n, anm[i][0], 8) != 0) {
+ while (i < ANIT - 1 && strncasecmp(n, anm[i][0], 8) != 0) {
i++;
}
- return i < ANIT ? i + 1 : 0;
+ return i < ANIT - 1 ? i + 1 : 0;
}
int R_get_special_id (int n) {
assert(n >= 0 && n <= 256);
- return walp[n].res == -2 ? walp[n].id : -1;
+ return walp[n].res == -2 ? (intptr_t)walp[n].n : -1;
+}
+
+static void R_reload_textures (void) {
+ int i;
+ char s[8];
+ for (i = 0; i < max_textures; i++) {
+ R_get_name(i, s);
+ if (walp[i].res >= 0) {
+ walp[i] = R_gl_getimage(walp[i].res);
+ }
+ }
+ if (horiz.n) {
+ horiz = R_gl_getimage(horiz.res);
+ }
}
void R_begin_load (void) {
int i;
for (i = 0; i < 256; i++) {
- if (walp[i].id != 0 && walp[i].res >= 0 && walani[i] == 0) {
+ if (walp[i].n != NULL && walp[i].res >= 0 && walani[i] == 0) {
R_gl_free_image(&walp[i]);
}
memset(&walp[i], 0, sizeof(image));
assert(max_textures < 256);
if (!s[0]) {
walp[max_textures] = (image) {
- .id = 0,
+ .n = NULL,
.x = 0,
.y = 0,
.w = 0,
};
} else if (strncasecmp(s, "_WATER_", 7) == 0) {
walp[max_textures] = (image) {
- .id = s[7] - '0' + 1,
+ .n = (void*)((intptr_t)s[7] - '0' + 1),
.x = 0,
.y = 0,
.w = 8,
if (k >= 256) {
k = j;
j += 1;
+ max_textures += 1;
walp[k] = R_gl_getimage(g);
walf[k] = g & 0x8000 ? 1 : 0;
}
void R_loadsky (int sky) {
char s[6];
- logo("R_loadsky(%i)\n", sky);
strcpy(s, "RSKYx");
s[4] = '0' + sky;
R_gl_free_image(&horiz);
horiz = R_gl_loadimage(s);
-}
\ No newline at end of file
+}