diff --git a/src/gl/render.c b/src/gl/render.c
index e74d6bb5229989165983fcc619a715a25cfdd41c..68ab733d1da170d5e1b4ef6fd32be59d2a5a8903 100644 (file)
--- a/src/gl/render.c
+++ b/src/gl/render.c
+/* Copyright (C) 2020 SovietPony
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3 of the License ONLY.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
#include "glob.h"
#include "render.h"
+#include "system.h"
#include "files.h"
#include "memory.h"
#include "misc.h"
#include "dots.h"
#include "items.h"
-#include "sound.h" // snd_vol
-#include "music.h" // mus_vol
+#include "sound.h"
+#include "music.h"
#include "fx.h"
#include "player.h"
#include "view.h"
#include "switch.h" // sw_secrets
+#include "cp866.h"
+
#ifdef __APPLE__
# include <OpenGL/gl.h>
#else
# include <GL/gl.h>
#endif
-#include <stdlib.h> // malloc free abs
-#include <assert.h> // assert
-#include <SDL.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
#define VGA_TRANSPARENT_COLOR 0
#define DEFAULT_SKY_COLOR 0x97
typedef struct node {
struct cache *base;
struct node *left, *right;
+ struct node *up;
int l, t, r, b;
int leaf;
} node;
} image;
/* Render Specific */
-int SCRW = 320; // public
-int SCRH = 200; // public
-static int gamma;
-static int fullscreen;
-static SDL_Surface *surf;
+static int SCRW;
+static int SCRH;
+static float screen_scale;
+static int screen_width = 320;
+static int screen_height = 200;
+static byte screen_full = 0;
+static int init_screen_width = 0;
+static int init_screen_height = 0;
+static byte init_screen_full = 0xFF;
static rgb playpal[256];
static byte bright[256];
+static GLuint lastTexture;
static cache *root;
/* Game */
{"W73A_1", "W73A_2", NULL, NULL, NULL},
{"RP2_1", "RP2_2", "RP2_3", "RP2_4", NULL}
};
+static byte w_horiz = 1;
static int max_wall_width;
static int max_wall_height;
static int max_textures;
static image walp[256];
+static byte walswp[256];
static byte walani[256];
static image anip[ANIT][5];
static byte anic[ANIT];
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,
};
} 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,
}
}
-static cache *R_cache_new (void) {
- GLuint id = 0;
+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;
- cache *c = NULL;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size);
- size /= 2; // TODO remove hack or detect ibook bug
- if (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) {
- glBindTexture(GL_TEXTURE_2D, 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, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
- int ok = glGetError() == GL_NO_ERROR;
- glBindTexture(GL_TEXTURE_2D, 0);
- if (ok) {
- c = malloc(sizeof(cache));
- if (c != NULL) {
- *c = (cache) {
- .id = id,
- .root.r = size - 1,
- .root.b = size - 1
- };
- }
- }
- if (c == NULL) {
+ 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);
+ //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;
- while (c && !n) {
- n = R_node_alloc(&c->root, w, h);
- if (n) {
- n->base = c;
- }
- p = c;
- c = c->next;
- }
- if (!n) {
- c = R_cache_new();
- if (c) {
- p->next = c;
+ 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 w, int h) {
+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);
- int nw = n->r - n->l + 1;
- int nh = n->b - n->t + 1;
- assert(w == nw);
- assert(h == nh);
- glBindTexture(GL_TEXTURE_2D, n->base->id);
- glTexSubImage2D(GL_TEXTURE_2D, 0, n->l, n->t, nw, nh, GL_RGBA, GL_UNSIGNED_BYTE, data);
- assert(glGetError() == GL_NO_ERROR);
- glBindTexture(GL_TEXTURE_2D, 0);
+ 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 image R_gl_create_image (const rgba *buf, int w, int h) {
node *n = R_cache_alloc(root, w, h);
if (n) {
- R_cache_update(n, buf, w, h);
+ R_cache_update(n, buf, 0, 0, w, h);
}
return (image) {
.n = n,
}
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;
}
}
static image R_gl_get_special_spr (const char n[4], int s, int d, rgba *(*fn)(vgaimg*)) {
- return R_gl_get_special_image(F_getsprid(n, s, d), fn);
+ return R_gl_get_special_image(F_getsprid(n, s, d, NULL), fn);
}
static void R_gl_free_image (image *img) {
if (img->n != NULL && img->res >= 0) {
- // TODO delete node
+ R_node_free(img->n);
}
img->n = NULL;
+ img->res = -1;
}
-static void R_gl_draw_quad (int x, int y, int w, int h) {
- glBegin(GL_QUADS);
+static void R_gl_quad_vetexes (int x, int y, int w, int h) {
glVertex2i(x + w, y);
glVertex2i(x, y);
glVertex2i(x, y + h);
glVertex2i(x + w, y + h);
+}
+
+static void R_gl_draw_quad (int x, int y, int w, int h) {
+ glBegin(GL_QUADS);
+ R_gl_quad_vetexes(x, y, w, h);
glEnd();
}
@@ -475,7 +589,7 @@ static void R_gl_draw_textured (image *img, int x, int y, int w, int h, int flip
GLfloat bx = (flip ? img->n->r + 1 : img->n->l) / nh;
GLfloat ay = (img->n->t) / nw;
GLfloat by = (img->n->b + 1) / nh;
- glBindTexture(GL_TEXTURE_2D, img->n->base->id);
+ R_gl_bind_texture(img->n->base->id);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(ax, ay); glVertex2i(x + w, y);
@@ -483,12 +597,11 @@ static void R_gl_draw_textured (image *img, int x, int y, int w, int h, int flip
glTexCoord2f(bx, by); glVertex2i(x, y + h);
glTexCoord2f(ax, by); glVertex2i(x + w, y + h);
glEnd();
- glDisable(GL_TEXTURE_2D);
- glBindTexture(GL_TEXTURE_2D, 0);
} 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);
}
}
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) {
}
static void R_gl_setclip (int x, int y, int w, int h) {
- glScissor(x, SCRH - h - y, w, h);
+ glScissor(x * screen_scale, (SCRH - h - y) * screen_scale, w * screen_scale, h * screen_scale);
}
static void R_gl_setmatrix (void) {
- glScissor(0, 0, SCRW, SCRH);
- glViewport(0, 0, SCRW, SCRH);
+ SCRW = screen_width / screen_scale;
+ SCRH = screen_height / screen_scale;
+ glScissor(0, 0, screen_width, screen_height);
+ glViewport(0, 0, screen_width, screen_height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, SCRW, SCRH, 0, 0, 1);
/* --- Misc --- */
static image Z_getspr (const char n[4], int s, int d, char *dir) {
- int h = F_getsprid(n, s, d);
- if (dir != NULL) {
- *dir = (h & 0x8000) ? 1 : 0;
- }
+ int h = F_getsprid(n, s, d, dir);
return R_gl_getimage(h);
}
-static void Z_putch_generic (image img[], int off, int ch) {
+static image *Z_get_char_image (image *img, int ch) {
image *p = NULL;
+ ch = cp866_toupper(ch);
if (ch > 32 && ch < 160) {
p = &img[ch - '!'];
}
- if (p != NULL) {
+ return p;
+}
+
+static int Z_get_char_width_generic (image *img, int off, int ch) {
+ image *p = Z_get_char_image(img, ch);
+ return p == NULL ? off : p->w - 1;
+}
+
+static int Z_putch_generic (image *img, int off, int ch) {
+ image *p = Z_get_char_image(img, ch);
+ int w = p == NULL ? off : p->w - 1;
+ if (p != NULL && p->n != NULL) {
R_gl_draw_image(p, prx, pry, 0);
- prx += p->w - 1;
- } else {
- prx += off;
}
+ prx += w;
+ return w;
}
-static void Z_printf_generic (image img[], int off, const char *fmt, va_list ap) {
- int i;
+static int Z_get_string_width_generic (image *img, int off, const char *fmt, va_list ap) {
+ int i, w, ww;
char buf[80];
vsprintf(buf, fmt, ap);
- for (i = 0; buf[i]; ++i) {
+ for (i = w = ww = 0; buf[i]; ++i) {
+ switch (buf[i]) {
+ case '\n':
+ case '\r':
+ ww = max(w, ww);
+ w = 0;
+ break;
+ default:
+ w += Z_get_char_width_generic(img, off, (byte)buf[i]);
+ }
+ }
+ return max(w, ww);
+}
+
+static int Z_printf_generic (image *img, int off, const char *fmt, va_list ap) {
+ int i, w, ww;
+ char buf[80];
+ vsprintf(buf, fmt, ap);
+ for (i = w = ww = 0; buf[i]; ++i) {
switch (buf[i]) {
case '\n':
pry += off + 1;
case '\r':
+ w = max(w, ww);
prx = 0;
+ w = 0;
break;
default:
- Z_putch_generic(img, off, (byte)buf[i]);
+ w += Z_putch_generic(img, off, (byte)buf[i]);
}
}
+ return w;
}
static void Z_gotoxy (int x, int y) {
pry = y;
}
-static void Z_printbf (const char *fmt, ...) {
+static int Z_get_big_string_width (const char *fmt, ...) {
+ va_list a;
+ va_start(a, fmt);
+ int w = Z_get_string_width_generic(bfh, 12, fmt, a);
+ va_end(a);
+ return w;
+}
+
+static int Z_printbf (const char *fmt, ...) {
va_list a;
va_start(a, fmt);
- Z_printf_generic(bfh, 12, fmt, a);
+ int w = Z_printf_generic(bfh, 12, fmt, a);
va_end(a);
+ return w;
}
-static void Z_printsf (const char *fmt, ...) {
+static int Z_get_small_string_width (const char *fmt, ...) {
va_list a;
va_start(a, fmt);
- Z_printf_generic(sfh, 7, fmt, a);
+ int w = Z_get_string_width_generic(sfh, 7, fmt, a);
va_end(a);
+ return w;
+}
+
+static int Z_printsf (const char *fmt, ...) {
+ va_list a;
+ va_start(a, fmt);
+ int w =Z_printf_generic(sfh, 7, fmt, a);
+ va_end(a);
+ return w;
}
static void Z_printhf (const char *fmt, ...) {
return msk ? &plr_msk[i] : &plr_spr[i];
}
-static void GM_draw (void) {
- enum {MENU, MSG}; // copypasted from menu.c!
- enum {
- CANCEL, NEWGAME, LOADGAME, SAVEGAME, OPTIONS, QUITGAME, QUIT, ENDGAME, ENDGM,
- PLR1, PLR2, COOP, DM, VOLUME, GAMMA, LOAD, SAVE, PLCOLOR, PLCEND, MUSIC, INTERP,
- SVOLM, SVOLP, MVOLM, MVOLP, GAMMAM, GAMMAP, PL1CM, PL1CP, PL2CM, PL2CP
- }; // copypasted from menu.c!
- int i, j, k, x, y, cx, cy;
- image *img;
- gm_tm += 1;
- if (mnu != NULL) {
- cx = SCRW / 2;
- cy = SCRH / 2;
- if (mnu->type == MENU) {
- y = cy - (mnu->n * 16 - 20) / 2;
- Z_gotoxy(cx - mnu->x, y - 10); Z_printbf("%s", mnu->ttl);
- for (i = 0; i < mnu->n; i++) {
- if (mnu->t[i] == LOAD || mnu->t[i] == SAVE) {
- j = y + i * 16 + 29;
- R_gl_draw_image(&mslotl, cx - mnu->x, j, 0);
- for (k = 8; k < 184; k += 8) {
- R_gl_draw_image(&mslotm, cx - mnu->x + k, j, 0);
+#define SCROLLER_MIDDLE 10
+#define TEXTFIELD_MIDDLE 2
+
+static void get_entry_size (const menu_t *m, int i, int *w, int *h) {
+ assert(m != NULL);
+ assert(i >= 0);
+ assert(w != NULL);
+ assert(h != NULL);
+ int x = 0;
+ int y = 0;
+ int type = 0;
+ menu_msg_t msg;
+ msg.type = GM_GETENTRY;
+ if (GM_send(m, i, &msg)) {
+ type = msg.integer.i;
+ switch (type) {
+ case GM_BUTTON:
+ case GM_SCROLLER:
+ case GM_TEXTFIELD:
+ case GM_TEXTFIELD_BUTTON:
+ msg.type = GM_GETCAPTION;
+ if (GM_send(m, i, &msg)) {
+ x = Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s);
+ }
+ break;
+ case GM_SMALL_BUTTON:
+ msg.type = GM_GETCAPTION;
+ if (GM_send(m, i, &msg)) {
+ x = Z_get_small_string_width("%.*s", msg.string.maxlen, msg.string.s);
+ }
+ break;
+ default:
+ assert(0);
+ }
+ switch (type) {
+ case GM_BUTTON:
+ msg.type = GM_GETSTR;
+ if (GM_send(m, i, &msg)) {
+ x += Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s);
+ }
+ y = 16;
+ break;
+ case GM_SMALL_BUTTON:
+ msg.type = GM_GETSTR;
+ if (GM_send(m, i, &msg)) {
+ x += Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s);
+ }
+ y = 12;
+ break;
+ case GM_SCROLLER:
+ x += (SCROLLER_MIDDLE + 2) * 8;
+ y = 16;
+ break;
+ case GM_TEXTFIELD:
+ case GM_TEXTFIELD_BUTTON:
+ msg.type = GM_GETSTR;
+ if (GM_send(m, i, &msg)) {
+ x += (msg.string.maxlen + 2) * 8;
+ } else {
+ x += (TEXTFIELD_MIDDLE + 2) * 8;
+ }
+ y = 16;
+ break;
+ default:
+ assert(0);
+ }
+ }
+ *w = x;
+ *h = y;
+}
+
+static void get_menu_size (const menu_t *m, int *w, int *h) {
+ assert(m != NULL);
+ assert(w != NULL);
+ assert(h != NULL);
+ int i, n, x, y, xx, yy, type;
+ menu_msg_t msg;
+ msg.type = GM_QUERY;
+ if (GM_send_this(m, &msg)) {
+ n = msg.integer.b;
+ type = msg.integer.s;
+ x = 0;
+ y = 0;
+ msg.type = GM_GETTITLE;
+ if (GM_send_this(m, &msg)) {
+ switch (type) {
+ case GM_BIG: x = Z_get_big_string_width("%.*s", msg.string.maxlen, msg.string.s); break;
+ case GM_SMALL: x = Z_get_small_string_width("%.*s", msg.string.maxlen, msg.string.s); break;
+ default: assert(0);
+ }
+ }
+ for (i = 0; i < n; i++) {
+ get_entry_size(m, i, &xx, &yy);
+ x = max(x, xx);
+ y += yy;
+ }
+ *w = x;
+ *h = y;
+ } else {
+ *w = 0;
+ *h = 0;
+ }
+}
+
+static int GM_draw (void) {
+ int i, j, n, x, y, xoff, yoff, cur, w, type, recv;
+ const menu_t *m = GM_get();
+ menu_msg_t msg;
+ if (m != NULL) {
+ get_menu_size(m, &x, &y);
+ x = SCRW / 2 - x / 2;
+ y = SCRH / 2 - y / 2;
+ // --- title ---
+ msg.type = GM_QUERY;
+ if (GM_send_this(m, &msg)) {
+ cur = msg.integer.i;
+ n = msg.integer.a;
+ type = msg.integer.s;
+ msg.type = GM_GETTITLE;
+ if (GM_send_this(m, &msg)) {
+ Z_gotoxy(x, y - 10);
+ switch (type) {
+ case GM_SMALL: yoff = 8; Z_printsf("%.*s", msg.string.maxlen, msg.string.s); break;
+ case GM_BIG: yoff = 20; Z_printbf("%.*s", msg.string.maxlen, msg.string.s); break;
+ default: assert(0);
+ }
+ } else {
+ yoff = 0;
+ }
+ for (i = 0; i < n; i++) {
+ msg.type = GM_GETENTRY;
+ if (GM_send(m, i, &msg)) {
+ type = msg.integer.i;
+ if (i == cur) {
+ if (type == GM_SMALL_BUTTON) {
+ Z_gotoxy(x - 8, y + yoff);
+ Z_printsf(">");
+ } else {
+ R_gl_draw_image(&msklh[(gm_tm / 6) & 1], x - 25, y + yoff - 8, 0);
+ }
}
- R_gl_draw_image(&mslotr, cx - mnu->x + 184, j, 0);
- Z_gotoxy(cx - mnu->x + 4, j - 8);
- if (input && i == save_mnu.cur) {
- Z_printsf("%s_", ibuf);
+ msg.type = GM_GETCAPTION;
+ if (GM_send(m, i, &msg)) {
+ Z_gotoxy(x, y + yoff);
+ if (type == GM_SMALL_BUTTON) {
+ xoff = Z_printsf("%.*s", msg.string.maxlen, msg.string.s);
+ } else {
+ xoff = Z_printbf("%.*s", msg.string.maxlen, msg.string.s);
+ }
} else {
- Z_printsf("%s", savname[i]);
+ xoff = 0;
}
- } else {
- x = mnu->t[i] >= SVOLM ? (mnu->t[i] >= PL1CM ? 50 : 152) : 0;
- Z_gotoxy(cx - mnu->x + x, y + i * 16 + 20);
- Z_printbf("%s", mnu->m[i]);
- switch (mnu->t[i]) {
- case MUSIC:
- Z_printbf(" '%s'", g_music);
- break;
- case INTERP:
- Z_printbf("%s", fullscreen ? "ON" : "OFF");
+ switch (type) {
+ case GM_BUTTON:
+ case GM_SMALL_BUTTON:
+ msg.type = GM_GETSTR;
+ if (GM_send(m, i, &msg)) {
+ Z_gotoxy(x + xoff, y + yoff);
+ if (type == GM_SMALL_BUTTON) {
+ Z_printsf("%.*s", msg.string.maxlen, msg.string.s);
+ } else {
+ Z_printbf("%.*s", msg.string.maxlen, msg.string.s);
+ }
+ }
+ yoff += type == GM_BUTTON ? 16 : 12;
break;
- case PL1CM:
- case PL1CP:
- case PL2CM:
- case PL2CP:
- img = PL_getspr(*panimp, 0, 0);
- R_gl_draw_image(img, cx - mnu->x + (mnu->t[i] == PL1CM ? 15 : 35), y + i * 16 + 20 + 14, 0);
- img = PL_getspr(*panimp, 0, 1);
- R_gl_set_color(pcolortab[(mnu->t[i] == PL1CM) ? p1color : p2color] + PLAYER_COLOR_OFFSET);
- R_gl_draw_image_color(img, cx - mnu->x + (mnu->t[i] == PL1CM ? 15 : 35), y + i * 16 + 20 + 14, 0);
+ case GM_TEXTFIELD:
+ case GM_TEXTFIELD_BUTTON:
+ yoff += 9;
+ msg.type = GM_GETSTR;
+ recv = GM_send(m, i, &msg);
+ w = recv ? msg.string.maxlen : TEXTFIELD_MIDDLE;
+ R_gl_draw_image(&mslotl, x + xoff, y + yoff, 0);
+ for (j = 1; j <= w; j++) {
+ R_gl_draw_image(&mslotm, x + xoff + j * 8, y + yoff, 0);
+ }
+ R_gl_draw_image(&mslotr, x + xoff + j * 8, y + yoff, 0);
+ Z_gotoxy(x + xoff + 4, y + yoff - 7);
+ if (input && i == cur) {
+ Z_printsf("%.*s_", imax, ibuf);
+ } else if (recv) {
+ Z_printsf("%.*s", msg.string.maxlen, msg.string.s);
+ }
+ yoff += 7;
break;
- case SVOLM:
- case SVOLP:
- case MVOLM:
- case MVOLP:
- case GAMMAM:
- case GAMMAP:
- j = y + i * 16 + 20;
- R_gl_draw_image(&mbarl, cx - mnu->x, j, 0);
- for (k = 8; k < 144; k += 8) {
- R_gl_draw_image(&mbarm, cx - mnu->x + k, j, 0);
+ case GM_SCROLLER:
+ R_gl_draw_image(&mbarl, x + xoff, y + yoff, 0);
+ for (j = 1; j < SCROLLER_MIDDLE; j++) {
+ R_gl_draw_image(&mbarm, x + xoff + j * 8, y + yoff, 0);
}
- R_gl_draw_image(&mbarr, cx - mnu->x + 144, j, 0);
- switch (mnu->t[i]) {
- case SVOLM:
- k = snd_vol;
- break;
- case MVOLM:
- k = mus_vol;
- break;
- case GAMMAM:
- k = gamma << 5;
- break;
- default:
- k = 0;
- break;
+ R_gl_draw_image(&mbarr, x + xoff + j * 8, y + yoff, 0);
+ msg.type = GM_GETINT;
+ if (GM_send(m, i, &msg)) {
+ int lev = (msg.integer.i - msg.integer.a) * ((SCROLLER_MIDDLE - 2) * 8) / msg.integer.b;
+ R_gl_draw_image(&mbaro, x + xoff + lev + 8, y + yoff, 0);
}
- R_gl_draw_image(&mbaro, cx - mnu->x + 8 + k, j, 0);
+ yoff += 16;
break;
+ default:
+ assert(0);
}
}
}
- R_gl_draw_image(&msklh[(gm_tm / 6) & 1], cx - mnu->x - 25, y + mnu->cur * 16 + 20 - 8, 0);
- } else if (mnu->type == MSG) {
- Z_gotoxy(cx - strlen(mnu->ttl) * 7 / 2, cy - 10); Z_printsf(mnu->ttl);
- Z_gotoxy(cx - 24, SCRH / 2); Z_printsf("(Y/N)");
- } else {
- ERR_fatal("Unknown menu type %i\n", mnu->type);
}
}
+ return m != NULL;
}
/* --- View --- */
@@ -769,6 +1043,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 {
@@ -781,11 +1056,14 @@ 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;
- glBegin(GL_POINTS);
+ glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
+ glBegin(GL_QUADS);
for (i = 0; i < MAXDOT; i++) {
if (dot[i].t != 0) {
R_gl_set_color(dot[i].c);
- glVertex2i(dot[i].o.x, dot[i].o.y + 1);
+ R_gl_quad_vetexes(dot[i].o.x, dot[i].o.y, 1, 1);
}
}
glEnd();
R_gl_draw_image(&fx_spr[s], fx[i].x, fx[i].y, fx_sprd[s]);
break;
case BUBL:
- glBegin(GL_POINTS);
+ glDisable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_TEXTURE_2D);
R_gl_set_color(0xC0 + fx[i].s);
- glVertex2i(fx[i].x >> 8, (fx[i].y >> 8) + 1);
- glEnd();
+ R_gl_draw_quad(fx[i].x >> 8, fx[i].y >> 8, 1, 1);
break;
}
}
}
} 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) {
+static void R_alloc (void) {
char s[10];
int i, j, n;
logo("R_alloc: load graphics\n");
/* Game */
scrnh[0] = R_gl_loadimage("TITLEPIC");
- assert(scrnh[0].n);
scrnh[1] = R_gl_loadimage("INTERPIC");
scrnh[2] = R_gl_loadimage("ENDPIC");
for (i = 0; i < 2; i++) {
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++) {
}
}
-void R_init (void) {
- Uint32 flags = SDL_OPENGL;
- if (fullscreen) {
- flags = flags | SDL_FULLSCREEN;
- }
- if (SCRW <= 0 || SCRH <= 0) {
- ERR_failinit("Invalid screen size %ix%i\n", SCRW, SCRH);
- }
- 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());
+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();
+ if (root != NULL) {
+ R_cache_free(root, 0);
+ root = NULL;
+ }
+ int res = Y_set_videomode_opengl(w, h, fullscreen);
+ if (res == 0) {
+ if (was == 0) {
+ ERR_failinit("Unable to set video mode\n");
+ }
}
+ Y_get_videomode(&screen_width, &screen_height);
+ screen_full = Y_get_fullscreen();
+ screen_scale = max(1, screen_width / 320);
root = R_cache_new();
assert(root);
R_alloc();
+ R_reload_textures();
}
-void R_done (void) {
- // do nothing
+static int video_menu_handler (menu_msg_t *msg, const menu_t *m, int i) {
+ static int cur;
+ static int w, h, fullscreen;
+ static char buf[16];
+ static int buflen;
+ static int vmode;
+ const videomode_t *v;
+ enum { VIDEOMODE, FULLSCREEN, APPLY, __NUM__ };
+ static const simple_menu_t sm = {
+ GM_BIG, "Video", NULL,
+ {
+ { "Mode: ", NULL },
+ { "Fullscreen: ", NULL },
+ { "Apply ", NULL },
+ }
+ };
+ if (msg->type == GM_ENTER) {
+ Y_get_videomode(&w, &h);
+ fullscreen = Y_get_fullscreen();
+ v = Y_get_videomode_list_opengl(fullscreen);
+ vmode = 0;
+ while (vmode < v->n && v->modes[vmode].w != w && v->modes[vmode].h != h) {
+ vmode += 1;
+ }
+ if (vmode < v->n) {
+ w = v->modes[vmode].w;
+ h = v->modes[vmode].h;
+ }
+ snprintf(buf, 16, "%ix%i", w, h);
+ buflen = strlen(buf);
+ return 1;
+ }
+ if (i == VIDEOMODE) {
+ switch (msg->type) {
+ case GM_GETSTR: return GM_init_str(msg, buf, buflen);
+ case GM_SELECT:
+ v = Y_get_videomode_list_opengl(fullscreen);
+ vmode = vmode + 1 >= v->n ? 0 : vmode + 1;
+ if (v->n > 0) {
+ w = v->modes[vmode].w;
+ h = v->modes[vmode].h;
+ } else {
+ Y_get_videomode(&w, &h);
+ }
+ snprintf(buf, 16, "%ix%i", w, h);
+ buflen = strlen(buf);
+ return 1;
+ }
+ } else if (i == FULLSCREEN) {
+ switch (msg->type) {
+ case GM_GETSTR: return GM_init_str(msg, fullscreen ? "Yes" : "No ", 3);
+ case GM_SELECT: fullscreen = !fullscreen; return 1;
+ }
+ } else if (i == APPLY) {
+ switch (msg->type) {
+ case GM_SELECT: R_set_videomode(w, h, fullscreen); return 1;
+ }
+ }
+ return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
}
-void R_setgamma (int g) {
- gamma = g < 0 ? 0 : (g > 4 ? 4 : g);
+const menu_t *R_menu (void) {
+ static const menu_t m = { video_menu_handler };
+ return &m;
}
-int R_getgamma (void) {
- return gamma;
+const cfg_t *R_args (void) {
+ static const cfg_t args[] = {
+ { "fullscr", &init_screen_full, Y_SW_ON },
+ { "window", &init_screen_full, Y_SW_OFF },
+ { "width", &init_screen_width, Y_DWORD },
+ { "height", &init_screen_height, Y_DWORD },
+ { NULL, NULL, 0 } // end
+ };
+ return args;
}
-void R_toggle_fullscreen (void) {
- fullscreen = !fullscreen;
- if (surf) {
- R_init(); // recreate window
- }
+const cfg_t *R_conf (void) {
+ static const cfg_t conf[] = {
+ { "sky", &w_horiz, Y_SW_ON },
+ { "fullscreen", &screen_full, Y_SW_ON },
+ { "screen_width", &screen_width, Y_DWORD },
+ { "screen_height", &screen_height, Y_DWORD },
+ { NULL, NULL, 0 } // end
+ };
+ return conf;
+}
+
+void R_init (void) {
+ logo("R_init: intialize opengl render\n");
+ R_init_playpal();
+ init_screen_width = init_screen_width > 0 ? init_screen_width : screen_width;
+ init_screen_height = init_screen_height > 0 ? init_screen_height : screen_height;
+ init_screen_full = init_screen_full != 0xFF ? init_screen_full : screen_full;
+ R_set_videomode(init_screen_width, init_screen_height, init_screen_full);
+}
+
+void R_done (void) {
+ R_cache_free(root, 1);
+ Y_unset_videomode();
+ root = NULL;
}
void R_get_name (int n, char s[8]) {
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++) {
max_textures = 1;
}
-void R_load (char s[8], int f) {
+void R_load (char s[8]) {
assert(max_textures < 256);
if (!s[0]) {
walp[max_textures] = (image) {
};
} else {
walp[max_textures] = R_gl_loadimage(s);
- if (f) {
- walp[max_textures].res |= 0x8000;
- }
if (s[0] == 'S' && s[1] == 'W' && s[4] == '_') {
walswp[max_textures] = 0;
}
if (walswp[i] == 0) {
R_get_name(i, s);
s[5] ^= 1;
- g = F_getresid(s) | (walp[i].res & 0x8000);
+ g = F_getresid(s);
k = 1;
while (k < 256 && walp[k].res != g) {
k += 1;
if (k >= 256) {
k = j;
j += 1;
+ max_textures += 1;
walp[k] = R_gl_getimage(g);
- walf[k] = g & 0x8000 ? 1 : 0;
+ walf[k] = walf[i];
}
walswp[i] = k;
walswp[k] = i;
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);
}
+
+void R_switch_texture (int x, int y) {
+ assert(x >= 0 && x < FLDW);
+ assert(y >= 0 && y < FLDH);
+ fldb[y][x] = walswp[fldb[y][x]];
+}
+
+int R_get_swp (int n) {
+ assert(n >= 0 && n < 256);
+ return walswp[n];
+}