core/code/video/sdl/f_sdlrenderer.cpp

   1 /*
   2     fegdk: FE Game Development Kit
   3     Copyright (C) 2001-2008 Alexey "waker" Yakovenko
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19     Alexey Yakovenko
  20     waker@users.sourceforge.net
  21 */
  22
  23 // $Header$
  24 #include "pch.h"
  25 #include "config.h"
  26
  27 #include "f_types.h"
  28 #include "f_sdlrenderer.h"
  29 #include "f_baseviewport.h"
  30 #include "f_math.h"
  31 #include "f_sdlviewport.h"
  32 #include "f_sdlviewportdata.h"
  33 #include "f_engine.h"
  34 #include "f_application.h"
  35 #include "f_console.h"
  36 #include "f_error.h"
  37 #include "f_fragileobject.h"
  38 #include "f_resourcemgr.h"
  39 #include <GL/glew.h>
  40 #include "f_resourcemgr.h"
  41 #include "f_resourcetable.h"
  42 #include <SDL/SDL.h>
  43 #include <cvars.h>
  44
  45 namespace fe
  46 {
  47
  48         //-----------------------------------
  49         // sdlRendererData
  50         //-----------------------------------
  51
  52         sdlRendererData::sdlRendererData (void)
  53         {
  54                 // enum vidmodes
  55
  56                 mbWindowed = true;
  57
  58                 SDL_Rect **modes;
  59                 SDL_PixelFormat fmt32 = {NULL, 32, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  60                 SDL_PixelFormat fmt16 = {NULL, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  61
  62                 modes = SDL_ListModes (&fmt32, SDL_FULLSCREEN | SDL_HWSURFACE |
  63                 SDL_DOUBLEBUF | SDL_OPENGL);
  64                 addModes (modes, 32);
  65                 modes = SDL_ListModes (&fmt16, SDL_FULLSCREEN | SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_OPENGL);
  66                 addModes (modes, 16);
  67
  68                 if (mVidModes.empty ())
  69                         sys_error ("no suitable video modes found!\n");
  70                 size_t i;
  71                 int mode_800x600 = -1;
  72                 int mode_640x480 = -1;
  73                 for (i = 0; i < mVidModes.size (); i++)
  74                 {
  75                         fprintf (stderr, "found vidmode %dx%dx%d\n", mVidModes[i].w, mVidModes[i].h, mVidModes[i].bpp);
  76                         if (mVidModes[i].w == 800 && mVidModes[i].h == 600)
  77                                 mode_800x600 = i;
  78                         if (mVidModes[i].w == 640 && mVidModes[i].h == 480)
  79                                 mode_640x480 = i;
  80                 }
  81
  82                 mCurrentMode = 0;
  83                 if (mode_800x600 != -1)
  84                         mCurrentMode = mode_800x600;
  85                 else if (mode_640x480 != -1)
  86                         mCurrentMode = mode_640x480;
  87         }
  88
  89         void    sdlRendererData::reset (void)
  90         {
  91                 SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
  92 //              SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
  93                 SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
  94
  95                 int flags = SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_OPENGL;
  96                 if (!mbWindowed)
  97                         flags |= SDL_FULLSCREEN;
  98                 SDL_SetVideoMode (mVidModes[mCurrentMode].w, mVidModes[mCurrentMode].h, mVidModes[mCurrentMode].bpp, flags);
  99
 100                 // fullscreen viewport
 101             glViewport (0, 0, mVidModes[mCurrentMode].w, mVidModes[mCurrentMode].h);
 102         }
 103
 104         void
 105         sdlRendererData::addModes (SDL_Rect **modes, int bpp)
 106         {
 107                 if (!modes)
 108                         return;
 109
 110                 if (modes == (void*) (-1))
 111                         sys_error ("SDL_ListModes returned -1. evil.");
 112
 113                 for (; *modes; modes++)
 114                 {
 115                         SDL_Rect *mode = *modes;
 116
 117                         size_t i;
 118                         for (i = 0; i < mVidModes.size (); i++)
 119                         {
 120                                 if (mVidModes[i].w == mode->w && mVidModes[i].h == mode->h && mVidModes[i].bpp == bpp)
 121                                         break;
 122                         }
 123
 124                         if (i == mVidModes.size ())
 125                         {
 126                                 vidMode_t vmode;
 127                                 vmode.w = mode->w;
 128                                 vmode.h = mode->h;
 129                                 vmode.bpp = bpp;
 130                                 mVidModes.push_back (vmode);
 131                         }
 132                 }
 133         }
 134
 135         sdlRendererData::~sdlRendererData (void)
 136         {
 137         }
 138
 139         size_t  sdlRendererData::numVidModes (void) const
 140         {
 141                 return mVidModes.size ();
 142         }
 143
 144         size_t  sdlRendererData::getCurrentVidMode (void) const
 145         {
 146                 return mCurrentMode;
 147         }
 148
 149         void    sdlRendererData::setCurrentVidMode (size_t mode)
 150         {
 151                 mCurrentMode = mode;
 152         }
 153
 154         const sdlRendererData::vidMode_t& sdlRendererData::getVidModeDescr (int mode) const
 155         {
 156                 return mVidModes[mode];
 157         }
 158
 159         void    sdlRendererData::setWindowed (bool windowed)
 160         {
 161                 mbWindowed = windowed;
 162         }
 163
 164         sdlRenderer::sdlRenderer (void)
 165         {
 166                 mbResetting = false;
 167             /* Setup our viewport. */
 168                 size_t curmode = mRendererData.getCurrentVidMode ();
 169                 const sdlRendererData::vidMode_t &descr = mRendererData.getVidModeDescr ( (int)curmode);
 170
 171                 fprintf (stderr, "SDL: setting render-related cvars...\n");
 172
 173                 // set cvars
 174                 cvarManager *cvars = g_engine->getCVarManager ();
 175                 cvars->setInt ("r_fullscreen", 0, true);
 176                 cvars->setInt ("r_vidmode", curmode, true);
 177
 178                 glRenderer::init ();
 179
 180                 fprintf (stderr, "sdl_opengl renderer initialization done.\n");
 181         }
 182
 183         sdlRenderer::~sdlRenderer (void)
 184         {
 185         }
 186
 187         void                            sdlRenderer::present (void)
 188         {
 189                 SDL_GL_SwapBuffers ();
 190         }
 191
 192         bool    sdlRenderer::isLost (void) const
 193         {
 194                 // for now - assume opengl buffers are restored automatically (though remember it is not really true)
 195                 return false;
 196         }
 197
 198         void                            sdlRenderer::resize (void)
 199         {
 200                 int mode = r_vidmode->ivalue;
 201                 int fullscreen = r_fullscreen->ivalue;
 202
 203                 // set modes to rendererdata
 204                 mRendererData.setCurrentVidMode (mode);
 205                 mRendererData.setWindowed (fullscreen ? false : true);
 206                 mRendererData.reset ();
 207
 208                 glRenderer::resize ();
 209         }
 210
 211         ulong                           sdlRenderer::numDisplayModes (ulong adapter, ulong device) const
 212         {
 213                 return (ulong)mRendererData.numVidModes ();
 214         }
 215
 216         cStr                            sdlRenderer::getDisplayModeDescr (ulong adapter, ulong device, ulong mode) const
 217         {
 218                 const sdlRendererData::vidMode_t &vmode = mRendererData.getVidModeDescr (mode);
 219                 cStr s;
 220                 s.printf ("%d x %d x %d", vmode.w, vmode.h, vmode.bpp);
 221                 return s;
 222         }
 223
 224         ulong                           sdlRenderer::numDevices (ulong adapter) const
 225         {
 226                 return 1;
 227         }
 228
 229         cStr                            sdlRenderer::getDeviceDescr (ulong adapter, ulong device) const
 230         {
 231                 return "SDL-opengl";
 232         }
 233
 234         ulong                           sdlRenderer::numAdapters (void) const
 235         {
 236                 return 1;
 237         }
 238
 239         cStr                            sdlRenderer::getAdapterDescr (ulong adapter) const
 240         {
 241                 return "default adapter";
 242         }
 243
 244         ulong                           sdlRenderer::getCurrentAdapter (void) const
 245         {
 246                 return 0;
 247         }
 248
 249         ulong                           sdlRenderer::getCurrentDevice (ulong adapter) const
 250         {
 251                 return 0;
 252         }
 253
 254         ulong                           sdlRenderer::getCurrentMode (ulong adapter, ulong device) const
 255         {
 256                 return 0;
 257         }
 258
 259         void                            sdlRenderer::setWindow (baseViewport *vp)
 260         {
 261                 // setting external window is not supported for opengl
 262                 // FIXME: should this method be completely abandoned?
 263         }
 264
 265
 266         sdlRendererData*                sdlRenderer::getData (void)
 267         {
 268                 return &mRendererData;
 269         }
 270
 271 }
 272