src/graphics/gropengl.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 #include "SDL_opengl.h"
  10
  11 #include "pstypes.h"
  12 #include "osregistry.h"
  13 #include "gropengl.h"
  14 #include "gropenglinternal.h"
  15 #include "grgl1.h"
  16 #include "grgl2.h"
  17 #include "grinternal.h"
  18 #include "cmdline.h"
  19 #include "mouse.h"
  20 #include "osapi.h"
  21
  22
  23 bool OGL_inited = false;
  24
  25 SDL_Window *GL_window = NULL;
  26 SDL_GLContext GL_context;
  27
  28 volatile int GL_activate = 0;
  29 volatile int GL_deactivate = 0;
  30
  31 int GL_viewport_x = 0;
  32 int GL_viewport_y = 0;
  33 int GL_viewport_w = 640;
  34 int GL_viewport_h = 480;
  35 float GL_viewport_scale_w = 1.0f;
  36 float GL_viewport_scale_h = 1.0f;
  37 int GL_min_texture_width = 0;
  38 int GL_max_texture_width = 0;
  39 int GL_min_texture_height = 0;
  40 int GL_max_texture_height = 0;
  41
  42 rb_t *render_buffer = NULL;
  43 static size_t render_buffer_size = 0;
  44
  45
  46 void opengl_alloc_render_buffer(unsigned int nelems)
  47 {
  48         if (nelems < 1) {
  49                 nelems = 1;
  50         }
  51
  52         if ( render_buffer && (nelems <= render_buffer_size) ) {
  53                 return;
  54         }
  55
  56         if (render_buffer) {
  57                 free(render_buffer);
  58         }
  59
  60         render_buffer = (rb_t*) malloc(sizeof(rb_t) * nelems);
  61         render_buffer_size = nelems;
  62 }
  63
  64 void opengl_free_render_buffer()
  65 {
  66         if (render_buffer) {
  67                 free(render_buffer);
  68                 render_buffer = NULL;
  69                 render_buffer_size = 0;
  70         }
  71 }
  72
  73 void opengl_set_variables()
  74 {
  75         GL_min_texture_height = 16;
  76         GL_min_texture_width = 16;
  77
  78         glGetIntegerv(GL_MAX_TEXTURE_SIZE, &GL_max_texture_width);
  79         GL_max_texture_height = GL_max_texture_width;
  80
  81         // no texture is larger than 1024, so maybe don't use sections
  82         if (GL_max_texture_width >= 1024) {
  83                 gr_screen.use_sections = 0;
  84         }
  85 }
  86
  87 void opengl_init_viewport()
  88 {
  89         GL_viewport_x = 0;
  90         GL_viewport_y = 0;
  91         GL_viewport_w = gr_screen.max_w;
  92         GL_viewport_h = gr_screen.max_h;
  93         GL_viewport_scale_w = 1.0f;
  94         GL_viewport_scale_h = 1.0f;
  95
  96         glViewport(GL_viewport_x, GL_viewport_y, GL_viewport_w, GL_viewport_h);
  97 }
  98
  99 void opengl_stuff_fog_value(float z, float *f_val)
 100 {
 101         float f_float;
 102
 103         if ( !f_val ) {
 104                 return;
 105         }
 106
 107         f_float = 1.0f - ((gr_screen.fog_far - z) / (gr_screen.fog_far - gr_screen.fog_near));
 108
 109         if (f_float < 0.0f) {
 110                 f_float = 0.0f;
 111         } else if (f_float > 1.0f) {
 112                 f_float = 1.0f;
 113         }
 114
 115         *f_val = f_float;
 116 }
 117
 118 void gr_opengl_clear()
 119 {
 120         glClearColor(gr_screen.current_clear_color.red / 255.0f,
 121                 gr_screen.current_clear_color.green / 255.0f,
 122                 gr_screen.current_clear_color.blue / 255.0f, 1.0f);
 123
 124         glClear( GL_COLOR_BUFFER_BIT );
 125 }
 126
 127 void gr_opengl_reset_clip()
 128 {
 129         gr_screen.offset_x = 0;
 130         gr_screen.offset_y = 0;
 131         gr_screen.clip_left = 0;
 132         gr_screen.clip_top = 0;
 133         gr_screen.clip_right = gr_screen.max_w - 1;
 134         gr_screen.clip_bottom = gr_screen.max_h - 1;
 135         gr_screen.clip_width = gr_screen.max_w;
 136         gr_screen.clip_height = gr_screen.max_h;
 137
 138         glDisable(GL_SCISSOR_TEST);
 139 }
 140
 141 uint gr_opengl_lock()
 142 {
 143         return 1;
 144 }
 145
 146 void gr_opengl_unlock()
 147 {
 148 }
 149
 150 void gr_opengl_zbias(int bias)
 151 {
 152         if (bias) {
 153                 glEnable(GL_POLYGON_OFFSET_FILL);
 154                 glPolygonOffset(0.0f, GLfloat(-bias));
 155         } else {
 156                 glDisable(GL_POLYGON_OFFSET_FILL);
 157         }
 158 }
 159
 160 void gr_opengl_set_cull(int cull)
 161 {
 162         if (cull) {
 163                 glEnable (GL_CULL_FACE);
 164                 glFrontFace (GL_CCW);
 165         } else {
 166                 glDisable (GL_CULL_FACE);
 167         }
 168 }
 169
 170 void gr_opengl_activate(int active)
 171 {
 172         if (active) {
 173                 GL_activate++;
 174         } else {
 175                 GL_deactivate++;
 176         }
 177 }
 178
 179 void gr_opengl_cleanup()
 180 {
 181         opengl1_cleanup();
 182         opengl2_cleanup();
 183
 184         opengl_free_render_buffer();
 185
 186         os_set_window(NULL);
 187
 188         SDL_DestroyWindow(GL_window);
 189         GL_window = NULL;
 190
 191         OGL_inited = false;
 192 }
 193
 194 void gr_opengl_init()
 195 {
 196         if ( OGL_inited )       {
 197                 gr_opengl_cleanup();
 198         }
 199
 200         mprintf(( "Initializing OpenGL graphics device...\n" ));
 201
 202         OGL_inited = true;
 203
 204         if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
 205                 Error(LOCATION, "Couldn't init SDL: %s", SDL_GetError());
 206         }
 207
 208         GL_window = SDL_CreateWindow(os_get_title(), SDL_WINDOWPOS_CENTERED,
 209                                                 SDL_WINDOWPOS_CENTERED,
 210                                                 gr_screen.max_w, gr_screen.max_h, SDL_WINDOW_OPENGL);
 211
 212         if ( !GL_window ) {
 213                 Error(LOCATION, "Couldn't create window: %s\n", SDL_GetError());
 214         }
 215
 216         os_set_window(GL_window);
 217
 218         int a = 1, r = 5, g = 5, b = 5, bpp = 16;
 219         int FSAA = os_config_read_uint("Video", "AntiAlias", 0);
 220
 221         SDL_GL_SetAttribute(SDL_GL_RED_SIZE, r);
 222         SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, g);
 223         SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, b);
 224         SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, a);
 225         SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, bpp);
 226
 227         if (FSAA) {
 228                 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
 229                 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, FSAA);
 230         }
 231
 232         int rc = 1;
 233
 234         // try GL 2 first, then fall back to GL 1
 235         if ( !opengl2_init() ) {
 236                 rc = opengl1_init();
 237         }
 238
 239         if ( !rc ) {
 240                 Error(LOCATION, "Unable to initialize OpenGL renderer!\n");
 241         }
 242
 243         mprintf(("  Attributes requested : ARGB %d%d%d%d, BPP %d, AA %d\n",
 244                          a, r, g, b, bpp, FSAA));
 245
 246         SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &r);
 247         SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &g);
 248         SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &b);
 249         SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &a);
 250         SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &bpp);
 251         SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &FSAA);
 252
 253         mprintf(("  Attributes received  : ARGB %d%d%d%d, BPP %d, AA %d\n",
 254                          a, r, g, b, bpp, FSAA));
 255         mprintf(("\n"));
 256
 257         SDL_DisableScreenSaver();
 258         SDL_ShowCursor(0);
 259
 260         // maybe go fullscreen - should be done *after* main GL init
 261         int fullscreen = os_config_read_uint("Video", "Fullscreen", 1);
 262         if ( !Cmdline_window && (fullscreen || Cmdline_fullscreen) ) {
 263                 gr_force_fullscreen();
 264                 // poll for window events
 265                 os_poll();
 266         }
 267
 268         switch (bpp) {
 269                 case 15:
 270                 case 16:
 271                         gr_screen.bits_per_pixel = 16;
 272                         gr_screen.bytes_per_pixel = 2;
 273
 274                         // screen values
 275                         Gr_red.bits = 5;
 276                         Gr_red.shift = 11;
 277                         Gr_red.scale = 8;
 278                         Gr_red.mask = 0x7C01;
 279
 280                         Gr_green.bits = 5;
 281                         Gr_green.shift = 6;
 282                         Gr_green.scale = 8;
 283                         Gr_green.mask = 0x3E1;
 284
 285                         Gr_blue.bits = 5;
 286                         Gr_blue.shift = 1;
 287                         Gr_blue.scale = 8;
 288                         Gr_blue.mask = 0x20;
 289
 290                         Gr_alpha.bits = 1;
 291                         Gr_alpha.shift = 0;
 292                         Gr_alpha.scale = 255;
 293                         Gr_alpha.mask = 0x1;
 294
 295                         break;
 296
 297                 case 24:
 298                 case 32:
 299                         gr_screen.bits_per_pixel = 32;
 300                         gr_screen.bytes_per_pixel = 4;
 301
 302                         // screen values
 303                         Gr_red.bits = 8;
 304                         Gr_red.shift = 0;
 305                         Gr_red.scale = 1;
 306                         Gr_red.mask = 0xff;
 307
 308                         Gr_green.bits = 8;
 309                         Gr_green.shift = 8;
 310                         Gr_green.scale = 1;
 311                         Gr_green.mask = 0xff00;
 312
 313                         Gr_blue.bits = 8;
 314                         Gr_blue.shift = 16;
 315                         Gr_blue.scale = 1;
 316                         Gr_blue.mask = 0xff0000;
 317
 318                         Gr_alpha.bits = 8;
 319                         Gr_alpha.shift = 24;
 320                         Gr_alpha.scale = 1;
 321                         Gr_alpha.mask = 0xff000000;
 322
 323                         break;
 324
 325                 default:
 326                         Int3(); // Illegal bpp
 327                         break;
 328         }
 329
 330         // DDOI - set these so no one else does!
 331         // texture values, always 5551 - 16-bit
 332         Gr_t_red.mask = 0x7C01;
 333         Gr_t_red.shift = 11;
 334         Gr_t_red.scale = 8;
 335
 336         Gr_t_green.mask = 0x3E1;
 337         Gr_t_green.shift = 6;
 338         Gr_t_green.scale = 8;
 339
 340         Gr_t_blue.mask = 0x20;
 341         Gr_t_blue.shift = 1;
 342         Gr_t_blue.scale = 8;
 343
 344         Gr_t_alpha.mask = 0x1;
 345         Gr_t_alpha.shift = 0;
 346         Gr_t_alpha.scale = 255;
 347
 348         // alpha-texture values
 349         Gr_ta_red.mask = 0x0f00;
 350         Gr_ta_red.shift = 8;
 351         Gr_ta_red.scale = 16;
 352
 353         Gr_ta_green.mask = 0x00f0;
 354         Gr_ta_green.shift = 4;
 355         Gr_ta_green.scale = 16;
 356
 357         Gr_ta_blue.mask = 0x000f;
 358         Gr_ta_blue.shift = 0;
 359         Gr_ta_blue.scale = 16;
 360
 361         Gr_ta_alpha.mask = 0xf000;
 362         Gr_ta_alpha.shift = 12;
 363         Gr_ta_alpha.scale = 16;
 364
 365         // default to screen
 366         Gr_current_red = &Gr_red;
 367         Gr_current_blue = &Gr_blue;
 368         Gr_current_green = &Gr_green;
 369         Gr_current_alpha = &Gr_alpha;
 370
 371
 372         Mouse_hidden++;
 373         gr_reset_clip();
 374         gr_clear();
 375         gr_flip();
 376         gr_clear();
 377         Mouse_hidden--;
 378 }