git.mutantstargoat.com Git - dosdemo/blob - src/sdl/main.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <math.h>
   4 #include <limits.h>
   5 #include <SDL/SDL.h>
   6 #include "demo.h"
   7 #include "tinyfps.h"
   8 #include "timer.h"
   9 #include "cfgopt.h"
  10 #include "sball.h"
  11 #include "vmath.h"
  12
  13 static void handle_event(SDL_Event *ev);
  14 static void toggle_fullscreen(void);
  15
  16 static int handle_sball_event(sball_event *ev);
  17 static void recalc_sball_matrix(float *xform);
  18
  19 static int sdlkey_to_demokey(int sdlkey, unsigned int mod);
  20
  21
  22 static int quit;
  23 static SDL_Surface *fbsurf;
  24
  25 static int fbscale = 2;
  26 static int xsz, ysz;
  27 static unsigned int sdl_flags = SDL_SWSURFACE;
  28
  29 static int use_sball;
  30 static vec3_t pos = {0, 0, 0};
  31 static quat_t rot = {0, 0, 0, 1};
  32
  33
  34 int main(int argc, char **argv)
  35 {
  36         int s;
  37         char *env;
  38
  39         if((env = getenv("FBSCALE")) && (s = atoi(env))) {
  40                 fbscale = s;
  41                 printf("Framebuffer scaling x%d\n", fbscale);
  42         }
  43
  44         xsz = fb_width * fbscale;
  45         ysz = fb_height * fbscale;
  46
  47         /* now start_loadscr sets up fb_pixels to the space used by the loading image,
  48          * so no need to allocate another framebuffer
  49          */
  50 #if 0
  51         /* allocate 1 extra row as a guard band, until we fucking fix the rasterizer */
  52         if(!(fb_pixels = malloc(fb_width * (fb_height + 1) * fb_bpp / CHAR_BIT))) {
  53                 fprintf(stderr, "failed to allocate virtual framebuffer\n");
  54                 return 1;
  55         }
  56 #endif
  57
  58         SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_NOPARACHUTE);
  59         if(!(fbsurf = SDL_SetVideoMode(xsz, ysz, fb_bpp, sdl_flags))) {
  60                 fprintf(stderr, "failed to set video mode %dx%d %dbpp\n", fb_width, fb_height, fb_bpp);
  61                 /*free(fb_pixels);*/
  62                 SDL_Quit();
  63                 return 1;
  64         }
  65         SDL_WM_SetCaption("dosdemo/SDL", 0);
  66         SDL_ShowCursor(0);
  67
  68         time_msec = 0;
  69         if(demo_init(argc, argv) == -1) {
  70                 /*free(fb_pixels);*/
  71                 SDL_Quit();
  72                 return 1;
  73         }
  74         vmem = fb_pixels;
  75
  76         if(opt.sball && sball_init() == 0) {
  77                 use_sball = 1;
  78         }
  79
  80         reset_timer();
  81
  82         while(!quit) {
  83                 SDL_Event ev;
  84                 while(SDL_PollEvent(&ev)) {
  85                         handle_event(&ev);
  86                         if(quit) goto break_evloop;
  87                 }
  88
  89                 if(use_sball) {
  90                         while(sball_pending()) {
  91                                 sball_event ev;
  92                                 sball_getevent(&ev);
  93                                 handle_sball_event(&ev);
  94                         }
  95                         recalc_sball_matrix(sball_matrix);
  96                 }
  97
  98                 time_msec = get_msec();
  99                 demo_draw();
 100         }
 101
 102 break_evloop:
 103         demo_cleanup();
 104         SDL_Quit();
 105         return 0;
 106 }
 107
 108 void demo_quit(void)
 109 {
 110         quit = 1;
 111 }
 112
 113 void wait_vsync(void)
 114 {
 115         unsigned long start = SDL_GetTicks();
 116         unsigned long until = (start | 0xf) + 1;
 117         while(SDL_GetTicks() <= until);
 118 }
 119
 120 void swap_buffers(void *pixels)
 121 {
 122         int i, j;
 123         unsigned short *sptr, *dptr;
 124
 125         demo_post_draw(pixels ? pixels : fb_pixels);
 126
 127         if(opt.vsync) {
 128                 wait_vsync();
 129         }
 130
 131         if(SDL_MUSTLOCK(fbsurf)) {
 132                 SDL_LockSurface(fbsurf);
 133         }
 134
 135         sptr = fb_pixels;
 136         dptr = (unsigned short*)fbsurf->pixels + (fbsurf->w - xsz) / 2;
 137         for(i=0; i<fb_height; i++) {
 138                 for(j=0; j<fb_width; j++) {
 139                         int x, y;
 140                         unsigned short pixel = *sptr++;
 141
 142                         for(y=0; y<fbscale; y++) {
 143                                 for(x=0; x<fbscale; x++) {
 144                                         dptr[y * fbsurf->w + x] = pixel;
 145                                 }
 146                         }
 147                         dptr += fbscale;
 148                 }
 149                 dptr += (fbsurf->w - fb_width) * fbscale;
 150         }
 151
 152         if(SDL_MUSTLOCK(fbsurf)) {
 153                 SDL_UnlockSurface(fbsurf);
 154         }
 155         SDL_Flip(fbsurf);
 156 }
 157
 158 static int bnmask(int sdlbn)
 159 {
 160         switch(sdlbn) {
 161         case SDL_BUTTON_LEFT:
 162                 return MOUSE_BN_LEFT;
 163         case SDL_BUTTON_RIGHT:
 164                 return MOUSE_BN_RIGHT;
 165         case SDL_BUTTON_MIDDLE:
 166                 return MOUSE_BN_MIDDLE;
 167         default:
 168                 break;
 169         }
 170         return 0;
 171 }
 172
 173 static void handle_event(SDL_Event *ev)
 174 {
 175         int key;
 176
 177         switch(ev->type) {
 178         case SDL_QUIT:
 179                 quit = 1;
 180                 break;
 181
 182         case SDL_KEYDOWN:
 183         case SDL_KEYUP:
 184                 if(ev->key.keysym.sym == SDLK_RETURN && (SDL_GetModState() & KMOD_ALT) &&
 185                                 ev->key.state == SDL_PRESSED) {
 186                         toggle_fullscreen();
 187                         break;
 188                 }
 189                 key = sdlkey_to_demokey(ev->key.keysym.sym, ev->key.keysym.mod);
 190                 demo_keyboard(key, ev->key.state == SDL_PRESSED ? 1 : 0);
 191                 break;
 192
 193         case SDL_MOUSEMOTION:
 194                 mouse_x = ev->motion.x / fbscale;
 195                 mouse_y = ev->motion.y / fbscale;
 196                 break;
 197
 198         case SDL_MOUSEBUTTONDOWN:
 199                 mouse_bmask |= bnmask(ev->button.button);
 200                 if(0) {
 201         case SDL_MOUSEBUTTONUP:
 202                         mouse_bmask &= ~bnmask(ev->button.button);
 203                 }
 204                 mouse_x = ev->button.x / fbscale;
 205                 mouse_y = ev->button.y / fbscale;
 206                 break;
 207
 208         default:
 209                 break;
 210         }
 211 }
 212
 213 static void toggle_fullscreen(void)
 214 {
 215         SDL_Surface *newsurf;
 216         unsigned int newflags = sdl_flags ^ SDL_FULLSCREEN;
 217
 218         if(!(newsurf = SDL_SetVideoMode(xsz, ysz, fb_bpp, newflags))) {
 219                 fprintf(stderr, "failed to go %s\n", newflags & SDL_FULLSCREEN ? "fullscreen" : "windowed");
 220                 return;
 221         }
 222
 223         fbsurf = newsurf;
 224         sdl_flags = newflags;
 225 }
 226
 227
 228
 229 #define TX(ev)  ((ev)->motion.motion[0])
 230 #define TY(ev)  ((ev)->motion.motion[1])
 231 #define TZ(ev)  ((ev)->motion.motion[2])
 232 #define RX(ev)  ((ev)->motion.motion[3])
 233 #define RY(ev)  ((ev)->motion.motion[4])
 234 #define RZ(ev)  ((ev)->motion.motion[5])
 235
 236 static int handle_sball_event(sball_event *ev)
 237 {
 238         switch(ev->type) {
 239         case SBALL_EV_MOTION:
 240                 if(RX(ev) | RY(ev) | RZ(ev)) {
 241                         float rx = (float)RX(ev);
 242                         float ry = (float)RY(ev);
 243                         float rz = (float)RZ(ev);
 244                         float axis_len = sqrt(rx * rx + ry * ry + rz * rz);
 245                         if(axis_len > 0.0) {
 246                                 rot = quat_rotate(rot, axis_len * 0.001, -rx / axis_len,
 247                                                 -ry / axis_len, -rz / axis_len);
 248                         }
 249                 }
 250
 251                 pos.x += TX(ev) * 0.001;
 252                 pos.y += TY(ev) * 0.001;
 253                 pos.z += TZ(ev) * 0.001;
 254                 break;
 255
 256         case SBALL_EV_BUTTON:
 257                 if(ev->button.pressed) {
 258                         pos = v3_cons(0, 0, 0);
 259                         rot = quat_cons(1, 0, 0, 0);
 260                 }
 261                 break;
 262         }
 263
 264         return 0;
 265 }
 266
 267 static void recalc_sball_matrix(float *xform)
 268 {
 269         quat_to_mat(xform, rot);
 270         xform[12] = pos.x;
 271         xform[13] = pos.y;
 272         xform[14] = pos.z;
 273 }
 274
 275 #define SSORG   '\''
 276 #define SSEND   '`'
 277 static char symshift[] = {
 278         '"', 0, 0, 0, 0, '<', '_', '>', '?',
 279         ')', '!', '@', '#', '$', '%', '^', '&', '*', '(',
 280         0, ':', 0, '+', 0, 0, 0,
 281         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 282         '{', '|', '}', 0, 0, '~'
 283 };
 284
 285
 286 static int sdlkey_to_demokey(int sdlkey, unsigned int mod)
 287 {
 288         if(sdlkey < 128) {
 289                 if(mod & (KMOD_SHIFT)) {
 290                         if(sdlkey >= 'a' && sdlkey <= 'z') {
 291                                 sdlkey = toupper(sdlkey);
 292                         } else if(sdlkey >= SSORG && sdlkey <= SSEND) {
 293                                 sdlkey = symshift[sdlkey - SSORG];
 294                         }
 295                 }
 296                 return sdlkey;
 297         }
 298         if(sdlkey < 256) return 0;
 299         return sdlkey - 128;
 300 }