Vendor the Shockolate engine and build it via a Docker image with every

dependency (SDL2, SDL2_mixer, fluidsynth-lite, a MIDI soundfont) prebuilt, so compiling the engine needs no network access - just the image and the engine source. Add res/assets/extract_assets.sh to pull the game's data files out of a purchased GOG installer, and a Makefile that assembles a runnable dist/ from the two. Also add `make package`, which builds a redistributable tarball that omits the proprietary game assets (shipping res/GET_ASSETS.txt instead) plus license information for both the MIT tooling and the GPLv3 engine, and a Gitea Actions workflow that builds and publishes it to dl.ladkau.de on every push.
2026-07-19 15:43:38 +02:00
parent 3ed6400466
commit a5ec8db5f7
826 changed files with 214554 additions and 0 deletions
@@ -0,0 +1,579 @@
+/*
+
+Copyright (C) 2015-2018 Night Dive Studios, LLC.
+
+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, either version 3 of the License, or
+(at your option) any later version.
+
+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 "cit2d.h"
+#include "gr2ss.h"
+#include "frtypes.h"
+#include "frintern.h"
+#include "frprotox.h"
+#include "gamescr.h"
+
+
+#ifdef STEREO_SUPPORT
+#include <i6dvideo.h>
+extern uchar inp6d_stereo_active;
+
+#define S_DELTA 5
+#endif
+
+#ifdef SVGA_SUPPORT
+uchar gr2ss_override = OVERRIDE_NONE;
+char convert_type = 0;
+char convert_use_mode = 0;
+
+char mode_count[MAX_CONVERT_TYPES];
+fix convert_x[MAX_CONVERT_TYPES][MAX_USE_MODES];
+fix convert_y[MAX_CONVERT_TYPES][MAX_USE_MODES];
+fix inv_convert_x[MAX_CONVERT_TYPES][MAX_USE_MODES];
+fix inv_convert_y[MAX_CONVERT_TYPES][MAX_USE_MODES];
+
+#define SVGA_CONV_NONE 0
+#define SVGA_CONV_NORMAL 1
+#define SVGA_CONV_SCREEN 2
+
+// Internal prototypes
+
+uchar perform_svga_conversion(uchar mask) {
+    extern uchar full_game_3d;
+
+    if (gr2ss_override & OVERRIDE_FAIL)
+        return (SVGA_CONV_NONE);
+    // for now -   if ((convert_use_mode == 0) && (!inp6d_stereo_active))
+    if (convert_use_mode == 0)
+        return (SVGA_CONV_NONE);
+    if (_fr->draw_canvas.bm.bits == grd_canvas->bm.bits)
+        return (SVGA_CONV_SCREEN);
+    if (grd_canvas->bm.bits == grd_screen_canvas->bm.bits)
+        return (SVGA_CONV_SCREEN);
+    if (gr2ss_override & mask)
+        return (SVGA_CONV_NORMAL);
+    if (convert_use_mode == 3) // KLC - the normal mode for Mac Shock.
+        return (SVGA_CONV_SCREEN);
+    return (SVGA_CONV_NONE);
+}
+
+// Conversion functions from "abstract" shock 2d functions
+// to the actual 2d functions, with appropriate compensations
+// for screen mode coordinates and aspect ratios.
+
+// Note, x and y already converted here!
+void ss_scale_string(char *s, short x, short y) {
+    // needs to scale still!
+    // know about different fonts instead?  That would be better...
+    grs_font *ttfont = (grs_font *)ResLock(RES_tinyTechFont);
+    grs_font *mlfont = (grs_font *)ResLock(RES_mediumLEDFont);
+    grs_font *f = gr_get_font();
+    int c = gr_get_fcolor();
+    Id use_font = ID_NULL;
+#ifdef STEREO_SUPPORT
+    uchar rv = perform_svga_conversion(OVERRIDE_SCALE);
+#endif
+
+    if (convert_use_mode == 0) {
+        gr_string(s, x, y);
+        return;
+    }
+
+    if ((f == ttfont) || (f == mlfont)) {
+        switch (convert_use_mode) {
+        case 1:
+            if (f == ttfont)
+                use_font = RES_tallTinyTechFont;
+            break;
+        case 2:
+        case 3:
+            if (f == ttfont)
+                use_font = RES_doubleTinyTechFont;
+            else if (f == mlfont)
+                use_font = RES_doubleMediumLEDFont;
+            break;
+        case 4:
+            if (f == ttfont)
+                use_font = RES_megaTinyTechFont;
+            else if (f == mlfont)
+                use_font = RES_megaMediumLEDFont;
+            break;
+        }
+#ifdef STEREO_SUPPORT
+        if ((rv == SVGA_CONV_SCREEN) && inp6d_stereo_active) {
+            if (use_font == ID_NULL) {
+                short w, h;
+                gr_string_size(s, (short *)&w, (short *)&h);
+                gr_push_canvas(i6d_ss->cf_left);
+                gr_set_font(f);
+                gr_set_fcolor(c);
+                gr_scale_string(s, x + S_DELTA, y, SCONV_X(w) + S_DELTA, SCONV_Y(h));
+                gr_pop_canvas();
+                gr_push_canvas(i6d_ss->cf_right);
+                gr_set_font(f);
+                gr_set_fcolor(c);
+                gr_scale_string(s, x - S_DELTA, y, SCONV_X(w) - S_DELTA, SCONV_Y(h));
+            } else {
+                gr_push_canvas(i6d_ss->cf_left);
+                gr_set_font((grs_font *)ResLock(use_font));
+                gr_set_fcolor(c);
+                gr_string(s, x + S_DELTA, y);
+                gr_pop_canvas();
+                gr_push_canvas(i6d_ss->cf_right);
+                gr_set_font((grs_font *)ResLock(use_font));
+                gr_set_fcolor(c);
+                gr_string(s, x - S_DELTA, y);
+            }
+            gr_pop_canvas();
+        } else {
+#endif
+            if (use_font == ID_NULL) {
+                short w, h;
+                gr_string_size(s, (short *)&w, (short *)&h);
+                gr_scale_string(s, x, y, SCONV_X(w), SCONV_Y(h));
+            } else {
+                gr_set_font((grs_font *)ResLock(use_font));
+                gr_string(s, x, y);
+            }
+#ifdef STEREO_SUPPORT
+        }
+#endif
+        if (use_font != ID_NULL)
+            ResUnlock(use_font);
+        gr_set_font(ttfont);
+        ResUnlock(RES_tinyTechFont);
+        ResUnlock(RES_mediumLEDFont);
+    } else {
+        // Attempt to scale it
+        short w, h;
+        gr_string_size(s, (short *)&w, (short *)&h);
+        gr_scale_string(s, x, y, SCONV_X(w), SCONV_Y(h));
+    }
+}
+
+void ss_string(char *s, short x, short y) {
+    uchar rv;
+    if ((rv = perform_svga_conversion(OVERRIDE_SCALE))) {
+#ifdef STEREO_SUPPORT
+        if ((rv == SVGA_CONV_SCREEN) && (inp6d_stereo_active)) {
+            gr_push_canvas(i6d_ss->cf_left);
+            if (convert_use_mode)
+                ss_scale_string(s, SCONV_X(x) + S_DELTA, SCONV_Y(y));
+            else
+                ss_scale_string(s, x + S_DELTA, y);
+            gr_set_canvas(i6d_ss->cf_right);
+            if (convert_use_mode)
+                ss_scale_string(s, SCONV_X(x) - S_DELTA, SCONV_Y(y));
+            else
+                ss_scale_string(s, x - S_DELTA, y);
+            gr_pop_canvas();
+        } else
+#endif
+            ss_scale_string(s, SCONV_X(x), SCONV_Y(y));
+    } else {
+        gr_string(s, x, y);
+    }
+}
+
+void ss_bitmap(grs_bitmap *bmp, short x, short y) {
+    uchar rv;
+    if ((rv = perform_svga_conversion(OVERRIDE_SCALE))) {
+#ifdef STEREO_SUPPORT
+        if ((rv == SVGA_CONV_SCREEN) && (inp6d_stereo_active)) {
+            gr_push_canvas(i6d_ss->cf_left);
+            if (convert_use_mode)
+                gr_scale_bitmap(bmp, SCONV_X(x) + S_DELTA, SCONV_Y(y), SCONV_X(bmp->w) + S_DELTA, SCONV_Y(bmp->h));
+            else
+                gr_bitmap(bmp, x + S_DELTA, y);
+            gr_set_canvas(i6d_ss->cf_right);
+            if (convert_use_mode)
+                gr_scale_bitmap(bmp, SCONV_X(x) - S_DELTA, SCONV_Y(y), SCONV_X(bmp->w) - S_DELTA, SCONV_Y(bmp->h));
+            else
+                gr_bitmap(bmp, x - S_DELTA, y);
+            gr_pop_canvas();
+        } else
+#endif
+            gr_scale_bitmap(bmp, SCONV_X(x), SCONV_Y(y), SCONV_X(bmp->w), SCONV_Y(bmp->h));
+        //      Warning(("scaling %d x %d to %d x %d\n",bmp->w,bmp->h,SCONV_X(bmp->w),SCONV_Y(bmp->h)));
+    } else
+        gr_bitmap(bmp, x, y);
+}
+
+void ss_ubitmap(grs_bitmap *bmp, short x, short y) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_scale_ubitmap(bmp, SCONV_X(x), SCONV_Y(y), SCONV_X(bmp->w), SCONV_Y(bmp->h));
+    else
+        gr_ubitmap(bmp, x, y);
+}
+
+void ss_noscale_bitmap(grs_bitmap *bmp, short x, short y) {
+    uchar rv;
+    if ((rv = perform_svga_conversion(OVERRIDE_SCALE))) // ?
+#ifdef STEREO_SUPPORT
+        if ((rv == SVGA_CONV_SCREEN) && (inp6d_stereo_active)) {
+            gr_push_canvas(i6d_ss->cf_left);
+            if (convert_use_mode)
+                gr_bitmap(bmp, SCONV_X(x) + S_DELTA, SCONV_Y(y));
+            else
+                gr_bitmap(bmp, x + S_DELTA, y);
+            gr_set_canvas(i6d_ss->cf_right);
+            if (convert_use_mode)
+                gr_bitmap(bmp, SCONV_X(x) - S_DELTA, SCONV_Y(y));
+            else
+                gr_bitmap(bmp, x - S_DELTA, y);
+            gr_pop_canvas();
+        } else
+#endif
+            gr_bitmap(bmp, SCONV_X(x), SCONV_Y(y));
+    else
+        gr_bitmap(bmp, x, y);
+}
+
+void ss_scale_bitmap(grs_bitmap *bmp, short x, short y, short w, short h) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_scale_bitmap(bmp, SCONV_X(x), SCONV_Y(y), SCONV_X(w), SCONV_Y(h));
+    else
+        gr_scale_bitmap(bmp, x, y, w, h);
+}
+
+void ss_rect(short x1, short y1, short x2, short y2) {
+    uchar rv;
+    if ((rv = perform_svga_conversion(OVERRIDE_SCALE))) {
+#ifdef STEREO_SUPPORT
+        if ((rv == SVGA_CONV_SCREEN) && (inp6d_stereo_active)) {
+            int c = gr_get_fcolor();
+            gr_push_canvas(i6d_ss->cf_left);
+            gr_set_fcolor(c);
+            if (convert_use_mode)
+                gr_rect(SCONV_X(x1) + S_DELTA, SCONV_Y(y1), SCONV_X(x2) + S_DELTA, SCONV_Y(y2));
+            else
+                gr_rect(x1 + S_DELTA, y1, x2 + S_DELTA, y2);
+            gr_set_canvas(i6d_ss->cf_right);
+            gr_set_fcolor(c);
+            if (convert_use_mode)
+                gr_rect(SCONV_X(x1) - S_DELTA, SCONV_Y(y1), SCONV_X(x2) - S_DELTA, SCONV_Y(y2));
+            else
+                gr_rect(x1 - S_DELTA, y1, x2 - S_DELTA, y2);
+            gr_pop_canvas();
+        } else
+#endif
+            gr_rect(SCONV_X(x1), SCONV_Y(y1), SCONV_X(x2), SCONV_Y(y2));
+    } else {
+        gr_rect(x1, y1, x2, y2);
+    }
+}
+
+void ss_box(short x1, short y1, short x2, short y2) {
+    uchar rv;
+    if ((rv = perform_svga_conversion(OVERRIDE_SCALE))) {
+#ifdef STEREO_SUPPORT
+        if ((rv == SVGA_CONV_SCREEN) && (inp6d_stereo_active)) {
+            int c = gr_get_fcolor();
+            gr_push_canvas(i6d_ss->cf_left);
+            gr_set_fcolor(c);
+            if (convert_use_mode)
+                gr_box(SCONV_X(x1) + S_DELTA, SCONV_Y(y1), SCONV_X(x2) + S_DELTA, SCONV_Y(y2));
+            else
+                gr_box(x1 + S_DELTA, y1, x2 + S_DELTA, y2);
+            gr_set_canvas(i6d_ss->cf_right);
+            gr_set_fcolor(c);
+            if (convert_use_mode)
+                gr_box(SCONV_X(x1) - S_DELTA, SCONV_Y(y1), SCONV_X(x2) - S_DELTA, SCONV_Y(y2));
+            else
+                gr_box(x1 - S_DELTA, y1, x2 - S_DELTA, y2);
+            gr_pop_canvas();
+        } else
+#endif
+            gr_box(RSCONV_X(x1), RSCONV_Y(y1), RSCONV_X(x2), RSCONV_Y(y2));
+    } else {
+        gr_box(x1, y1, x2, y2);
+    }
+}
+
+void ss_safe_set_cliprect(short x1, short y1, short x2, short y2) {
+    if (perform_svga_conversion(OVERRIDE_CLIP)) {
+        //      Warning(("setting rect (%d, %d) (%d,%d)!\n",SCONV_X(x1),SCONV_Y(y1),SCONV_X(x2),SCONV_Y(y2)));
+        safe_set_cliprect(SCONV_X(x1), SCONV_Y(y1), SCONV_X(x2), SCONV_Y(y2));
+    } else
+        safe_set_cliprect(x1, y1, x2, y2);
+}
+
+void ss_cset_cliprect(grs_canvas *pcanv, short x, short y, short w, short h) {
+    if (perform_svga_conversion(OVERRIDE_CLIP)) {
+        //      Warning(("cset to %d,%d   %d, %d!\n",SCONV_X(x), SCONV_Y(y), SCONV_X(w), SCONV_Y(h)));
+        gr_cset_cliprect(pcanv, SCONV_X(x), SCONV_Y(y), SCONV_X(w), SCONV_Y(h));
+    } else
+        gr_cset_cliprect(pcanv, x, y, w, h);
+}
+
+void ss_int_line(short x1, short y1, short x2, short y2) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_int_line(SCONV_X(x1), SCONV_Y(y1), SCONV_X(x2), SCONV_Y(y2));
+    else
+        gr_int_line(x1, y1, x2, y2);
+}
+
+void ss_thick_int_line(short x1, short y1, short x2, short y2) {
+    if (perform_svga_conversion(OVERRIDE_SCALE)) {
+        short min_y, max_y, use_y, min_x, max_x, use_x;
+        min_y = SCONV_Y(y1);
+        max_y = SCONV_Y(y1 + 1);
+        min_x = SCONV_X(x1);
+        max_x = SCONV_X(x1 + 1);
+        for (use_y = min_y; use_y < max_y; use_y++)
+            gr_int_line(SCONV_X(x1), use_y, SCONV_X(x2), SCONV_Y(y2) + use_y - min_y);
+        for (use_x = min_x; use_x < max_x; use_x++)
+            gr_int_line(use_x, SCONV_Y(y1), SCONV_X(x2) + use_x - min_x, SCONV_Y(y2));
+    } else
+        gr_int_line(x1, y1, x2, y2);
+}
+
+void ss_int_disk(short x1, short y1, short diam) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_int_disk(SCONV_X(x1), SCONV_Y(y1), SCONV_X(diam) >> 1);
+    // Hm, should we convert rad?
+    // Yes, but sadly it's hosed in 320x400 mode, where
+    // we need to draw an ellipse.  This stuff really
+    // needs to be in the 2D.
+    else
+        gr_int_disk(x1, y1, diam >> 1);
+}
+
+void ss_vline(short x1, short y1, short y2) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_vline(SCONV_X(x1), SCONV_Y(y1), SCONV_Y(y2));
+    else
+        gr_vline(x1, y1, y2);
+}
+
+void ss_hline(short x1, short y1, short x2) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_hline(SCONV_X(x1), SCONV_Y(y1), SCONV_X(x2));
+    else
+        gr_hline(x1, y1, x2);
+}
+
+void ss_fix_line(fix x1, fix y1, fix x2, fix y2) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_fix_line(FIXCONV_X(x1), FIXCONV_Y(y1), FIXCONV_X(x2), FIXCONV_Y(y2));
+    else
+        gr_fix_line(x1, y1, x2, y2);
+}
+
+void ss_thick_fix_line(fix x1, fix y1, fix x2, fix y2) {
+    if (perform_svga_conversion(OVERRIDE_SCALE)) {
+        fix min_y, max_y, use_y, min_x, max_x, use_x;
+        min_y = FIXCONV_Y(y1);
+        max_y = FIXCONV_Y(y1 + FIX_UNIT);
+        min_x = FIXCONV_X(x1);
+        max_x = FIXCONV_X(x1 + FIX_UNIT);
+        for (use_y = min_y; use_y < max_y; use_y = use_y + FIX_UNIT)
+            gr_fix_line(FIXCONV_X(x1), use_y, FIXCONV_X(x2), FIXCONV_Y(y2) + use_y - min_y);
+        for (use_x = min_x; use_x < max_x; use_x = use_x + FIX_UNIT)
+            gr_fix_line(use_x, FIXCONV_Y(y1), FIXCONV_X(x2) + use_x - min_x, FIXCONV_Y(y2));
+    } else
+        gr_fix_line(x1, y1, x2, y2);
+}
+
+void ss_get_bitmap(grs_bitmap *bmp, short x, short y) {
+    if (perform_svga_conversion(OVERRIDE_GET_BM))
+        gr_get_bitmap(bmp, SCONV_X(x), SCONV_Y(y));
+    else
+        gr_get_bitmap(bmp, x, y);
+}
+
+void ss_set_pixel(long color, short x, short y) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_set_pixel(color, SCONV_X(x), SCONV_Y(y));
+    else
+        gr_set_pixel(color, x, y);
+}
+
+void ss_set_thick_pixel(long color, short x, short y) {
+    if (perform_svga_conversion(OVERRIDE_SCALE)) {
+        //      gr_set_pixel(color, SCONV_X(x), SCONV_Y(y));
+        gr_set_fcolor(color);
+        gr_box(SCONV_X(x), SCONV_Y(y), SCONV_X(x + 1) - 1, SCONV_Y(y + 1) - 1);
+    } else
+        gr_set_pixel(color, x, y);
+}
+
+void ss_clut_ubitmap(grs_bitmap *bmp, short x, short y, uchar *cl) {
+    if (perform_svga_conversion(OVERRIDE_SCALE))
+        gr_clut_scale_ubitmap(bmp, SCONV_X(x), SCONV_Y(y), SCONV_X(bmp->w), SCONV_Y(bmp->h), cl);
+    else
+        gr_clut_ubitmap(bmp, x, y, cl);
+}
+
+// Registration!
+
+// Note that the zeroth element of the conversion arrays
+// are used to store the base size, since perform_svga_conversion
+// already filters out calls with use_mode of 0.
+void gr2ss_register_init(char ctype, short init_x, short init_y) {
+    convert_x[ctype][0] = fix_make(init_x, 0);
+    convert_y[ctype][0] = fix_make(init_y, 0);
+}
+
+#define WACKY_FIX_COMPENSATION
+void gr2ss_register_mode(char conv_mode, short nx, short ny) {
+    char m;
+    mode_count[conv_mode]++;
+    m = mode_count[conv_mode];
+    convert_x[conv_mode][m] = fix_div(fix_make(nx, 0), convert_x[conv_mode][0]);
+    convert_y[conv_mode][m] = fix_div(fix_make(ny, 0), convert_y[conv_mode][0]);
+    inv_convert_x[conv_mode][m] = fix_div(convert_x[conv_mode][0], fix_make(nx, 0));
+    inv_convert_y[conv_mode][m] = fix_div(convert_y[conv_mode][0], fix_make(ny, 0));
+
+#ifdef WACKY_FIX_COMPENSATION
+    // wacky fix point compensation!
+    if (convert_x[conv_mode][m] & 0xF)
+        convert_x[conv_mode][m]++;
+    if (convert_y[conv_mode][m] & 0xF)
+        convert_y[conv_mode][m]++;
+    if (inv_convert_x[conv_mode][m] & 0xF)
+        inv_convert_x[conv_mode][m]++;
+    if (inv_convert_y[conv_mode][m] & 0xF)
+        inv_convert_y[conv_mode][m]++;
+#endif
+}
+
+void ss_recompute_zoom(frc *which_frc, short oldm) {
+    fr_mod_cams(which_frc, FR_NOCAM, fix_div(convert_x[convert_type][convert_use_mode], convert_x[convert_type][oldm]));
+}
+
+void ss_point_convert(short *px, short *py, uchar down) {
+#ifdef SVGA_SUPPORT
+    if (convert_use_mode != 0) {
+        short ox, oy;
+        ox = *px;
+        oy = *py;
+        if (down) {
+            *px = INV_SCONV_X(*px);
+            *py = INV_SCONV_Y(*py);
+        } else {
+            *px = SCONV_X(*px);
+            *py = SCONV_Y(*py);
+        }
+        //      Warning(("%d >> %d %d --> %d %d\n",down,ox,oy,*px,*py));
+    }
+#endif
+}
+
+short ss_curr_mode_width(void) { return (SCONV_X(convert_x[convert_type][0])); }
+
+short ss_curr_mode_height(void) { return (SCONV_Y(convert_y[convert_type][0])); }
+
+// Basically, if you are in the secret hack mode 5
+// then MODE_SCONV_X will act as if you are in mode M
+// otherwise it behaves like SCONV_{X,Y}
+short MODE_SCONV_X(short cval, short m) {
+    if ((!m) || (convert_use_mode != 5))
+        return (SCONV_X(cval));
+    return (fast_fix_mul_int(fix_make(cval, 0), convert_x[convert_type][m]));
+}
+
+short MODE_SCONV_Y(short cval, short m) {
+    if ((!m) || (convert_use_mode != 5))
+        return (SCONV_Y(cval));
+    return (fast_fix_mul_int(fix_make(cval, 0), convert_y[convert_type][m]));
+}
+
+// This allows us to override the real mode with some
+// fake pretender mode, but only if we are in the magic hack mode 5
+short hack_mode_on;
+void ss_set_hack_mode(short new_m, short *tval) {
+    if ((convert_use_mode != 5) && (!hack_mode_on))
+        return;
+    if (new_m) {
+        *tval = convert_use_mode;
+        convert_use_mode = new_m;
+        hack_mode_on++;
+    } else {
+        convert_use_mode = *tval;
+        hack_mode_on--;
+    }
+}
+
+#endif
+
+void ss_mouse_convert(short *px, short *py, uchar down) {
+    if (convert_use_mode != 0) {
+#ifdef STEREO_SUPPORT
+        if (convert_use_mode == 5) {
+            switch (i6d_device) {
+            case I6D_CTM:
+                return;
+                break;
+            case I6D_VFX1:
+                if (down)
+                    *py = fix_int(fix_mul_div(fix_make(*py, 0), fix_make(200, 0), fix_make(480, 0)));
+                else
+                    *py = fix_int(fix_mul_div(fix_make(*py, 0), fix_make(480, 0), fix_make(200, 0)));
+                return;
+            }
+        }
+#endif
+
+        if (down) {
+            *px = INV_SCONV_X(*px);
+            *py = INV_SCONV_Y(*py);
+        } else {
+            *px = SCONV_X(*px);
+            *py = SCONV_Y(*py);
+        }
+    }
+}
+
+void ss_mouse_convert_round(short *px, short *py, uchar down) {
+    short ox, oy;
+
+    if (convert_use_mode != 0) {
+#ifdef STEREO_SUPPORT
+        if (convert_use_mode == 5) {
+            ss_mouse_convert(px, py, down);
+            return;
+        }
+#endif
+        ox = *px;
+        oy = *py;
+        if (down) {
+            *px = fix_int(INV_FIXCONV_X(fix_make(*px, 0x8000)));
+            *py = fix_int(INV_FIXCONV_Y(fix_make(*py, 0x8000)));
+        } else {
+            *px = fix_int(FIXCONV_X(fix_make(*px, 0x8000)));
+            *py = fix_int(FIXCONV_Y(fix_make(*py, 0x8000)));
+        }
+    }
+}
+
+void mouse_unconstrain(void) {
+    /*  for now
+    #ifdef SVGA_SUPPORT
+       if (convert_use_mode == 5)
+       {
+          switch (i6d_device)
+          {
+             case I6D_CTM:
+                mouse_constrain_xy(0,0,grd_cap->w-1,grd_cap->h-1);
+                break;
+             case I6D_VFX1:
+                mouse_constrain_xy(0,0,i6d_ss->scr_w >> 1, i6d_ss->scr_h);
+                break;
+          }
+       }
+       else
+    #endif  */
+    mouse_constrain_xy(0, 0, grd_cap->w - 1, grd_cap->h - 1);
+}