X-Git-Url: https://deadsoftware.ru/gitweb?p=flatwaifu.git;a=blobdiff_plain;f=src%2Fgl%2Frender.c;h=68ab733d1da170d5e1b4ef6fd32be59d2a5a8903;hp=e74d6bb5229989165983fcc619a715a25cfdd41c;hb=c0bb00824a48b78aee7140e3fa89ac69d59d7296;hpb=4026d71c7c19a786b09ac0f41ea51bd3e1d1a784

diff --git a/src/gl/render.c b/src/gl/render.c
index e74d6bb..68ab733 100644
--- a/src/gl/render.c
+++ b/src/gl/render.c
@@ -1,5 +1,21 @@
+/* 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"
@@ -10,8 +26,8 @@
 #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"
@@ -21,14 +37,17 @@
 #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
@@ -57,6 +76,7 @@ typedef struct rgba {
 typedef struct node {
   struct cache *base;
   struct node *left, *right;
+  struct node *up;
   int l, t, r, b;
   int leaf;
 } node;
@@ -75,13 +95,18 @@ typedef struct image {
 } 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 */
@@ -147,10 +172,12 @@ static const char *anm[ANIT - 1][5] = {
   {"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];
@@ -180,12 +207,14 @@ static node *R_node_alloc (node *p, int w, int h) {
       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,
@@ -193,12 +222,14 @@ static node *R_node_alloc (node *p, int w, int h) {
         };
       } 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,
@@ -210,79 +241,150 @@ static node *R_node_alloc (node *p, int w, int h) {
   }
 }
 
-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 */
@@ -414,7 +516,7 @@ static rgba *R_extract_rgba_spr (vgaimg *v) {
 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,
@@ -425,7 +527,10 @@ static image R_gl_create_image (const rgba *buf, int w, int h) {
 }
 
 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);
@@ -435,6 +540,10 @@ static image R_gl_get_special_image (int id, rgba *(*fn)(vgaimg*)) {
     img.res = id;
     M_unlock(v);
     free(buf);
+  } else {
+    img = (image) {
+      .res = id
+    };
   }
   return img;
 }
@@ -448,22 +557,27 @@ static image R_gl_loadimage (const char name[8]) {
 }
 
 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);
   }
 }
@@ -507,16 +620,12 @@ static void R_gl_draw_image_color (image *img, int x, int y, int flip) {
   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) {
@@ -524,12 +633,14 @@ 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);
@@ -540,41 +651,70 @@ static void R_gl_setmatrix (void) {
 /* --- 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) {
@@ -582,18 +722,36 @@ 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, ...) {
@@ -647,96 +805,212 @@ static image *PL_getspr (int s, int d, int msk) {
   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();
@@ -1086,10 +1364,11 @@ static void R_draw_effects (void) {
         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;
     }
   }
@@ -1121,6 +1400,8 @@ static void R_draw_view (int x, int y, int w, int h, int camx, int camy) {
     }
   } 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);
   }
@@ -1146,6 +1427,7 @@ static void R_draw_view (int x, int y, int w, int h, int camx, int camy) {
     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();
@@ -1165,22 +1447,25 @@ static void R_draw_player_view (player_t *p, int x, int y, int w, int h) {
   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);
     }
   }
@@ -1196,6 +1481,8 @@ static void R_draw_player_view (player_t *p, int x, int y, int w, int 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);
     }
@@ -1316,7 +1603,7 @@ static void W_act (void) {
 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) {
@@ -1348,16 +1635,15 @@ void R_draw (void) {
       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++) {
@@ -1563,7 +1849,7 @@ 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++) {
@@ -1577,43 +1863,132 @@ void R_alloc (void) {
   }
 }
 
-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]) {
@@ -1643,6 +2018,20 @@ int R_get_special_id (int n) {
   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++) {
@@ -1660,7 +2049,7 @@ void R_begin_load (void) {
   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) {
@@ -1682,9 +2071,6 @@ void R_load (char s[8], int f) {
     };
   } 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;
     }
@@ -1703,7 +2089,7 @@ void R_end_load (void) {
     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;
@@ -1711,8 +2097,9 @@ void R_end_load (void) {
       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;
@@ -1722,9 +2109,19 @@ void R_end_load (void) {
 
 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];
+}