Dogcows Code - chaz/yoink/blob - src/Moof/Video.cc

   1
   2 /*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
   3 **]  All rights reserved.
   4 *
   5 * vi:ts=4 sw=4 tw=75
   6 *
   7 * Distributable under the terms and conditions of the 2-clause BSD license;
   8 * see the file COPYING for a complete text of the license.
   9 *
  10 **************************************************************************/
  11
  12 #include "Dispatch.hh"
  13 #include "Error.hh"
  14 #include "Image.hh"
  15 #include "Log.hh"
  16 #include "Settings.hh"
  17 #include "Video.hh"
  18
  19
  20 namespace Mf {
  21
  22
  23 Video::Video()
  24 {
  25         init();
  26 }
  27
  28 Video::Video(const Attributes& attribs) :
  29         mAttribs(attribs)
  30 {
  31         init();
  32 }
  33
  34 Video::Video(const std::string& caption, const std::string& icon)
  35 {
  36         mAttribs.caption = caption;
  37         mAttribs.icon = icon;
  38
  39         init();
  40 }
  41
  42 void Video::init()
  43 {
  44         Error error = Backend::getError();
  45         if (error) error.raise();
  46
  47         mContext = 0;
  48         mFlags = 0;
  49
  50         setFull(mAttribs.fullscreen);
  51         setResizable(mAttribs.resizable);
  52         setOpenGLAttributes();
  53         setCaption(mAttribs.caption);
  54         setIcon();
  55         setCursorVisible(mAttribs.cursorVisible);
  56         setCursorGrab(mAttribs.cursorGrab);
  57         setVideoMode(mAttribs.mode);
  58
  59         video = this;
  60 }
  61
  62 void Video::recreateContext()
  63 {
  64         SDL_FreeSurface(mContext);
  65         mContext = 0;
  66         setVideoMode(mAttribs.mode);
  67 }
  68
  69 void Video::setOpenGLAttributes()
  70 {
  71         SDL_GL_SetAttribute(SDL_GL_RED_SIZE,
  72                                                 mAttribs.colorBuffer[0]);
  73         SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,
  74                                                 mAttribs.colorBuffer[1]);
  75         SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,
  76                                                 mAttribs.colorBuffer[2]);
  77         SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,
  78                                                 mAttribs.colorBuffer[3]);
  79         SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE,
  80                                                 mAttribs.frameBuffer);
  81         SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,
  82                                                 mAttribs.doubleBuffer);
  83         SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,
  84                                                 mAttribs.depthBuffer);
  85         SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE,
  86                                                 mAttribs.stencilBuffer);
  87         SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE,
  88                                                 mAttribs.accumBuffer[0]);
  89         SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE,
  90                                                 mAttribs.accumBuffer[1]);
  91         SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE,
  92                                                 mAttribs.accumBuffer[2]);
  93         SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE,
  94                                                 mAttribs.accumBuffer[3]);
  95         SDL_GL_SetAttribute(SDL_GL_STEREO,
  96                                                 mAttribs.stereo);
  97         SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,
  98                                                 mAttribs.multisampleBuffers);
  99         SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,
 100                                                 mAttribs.multisampleSamples);
 101         SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL,
 102                                                 mAttribs.swapControl);
 103         SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL,
 104                                                 mAttribs.hardwareOnly);
 105 }
 106
 107
 108 Video::~Video()
 109 {
 110         SDL_FreeSurface(mContext);
 111
 112         if (video == this) video = 0;
 113 }
 114
 115
 116 void Video::setVideoMode(const long mode[3])
 117 {
 118         if (mode != mAttribs.mode || !mContext)
 119         {
 120                 if (mContext) SDL_FreeSurface(mContext);
 121
 122                 mContext = SDL_SetVideoMode(mode[0], mode[1], mode[2],
 123                                 SDL_OPENGL | mFlags);
 124
 125                 if (mContext)
 126                 {
 127                         mAttribs.mode[0] = mode[0];
 128                         mAttribs.mode[1] = mode[1];
 129                         mAttribs.mode[2] = mode[2];
 130
 131 #if !defined(linux) && !defined(__linux) && !defined(__linux__)
 132                         logInfo("video context recreated");
 133                         core.dispatch("video.newcontext");
 134 #endif
 135                 }
 136                 else Error(Error::SDL_VIDEOMODE).raise();
 137         }
 138 }
 139
 140 Video::Attributes Video::getAttributes() const
 141 {
 142         return mAttribs;
 143 }
 144
 145
 146 void Video::resize(int width, int height)
 147 {
 148         long mode[] = {width, height, mAttribs.mode[2]};
 149         setVideoMode(mode);
 150 }
 151
 152 bool Video::iconify()
 153 {
 154         return SDL_WM_IconifyWindow();
 155 }
 156
 157
 158 void Video::setCaption(const std::string& caption)
 159 {
 160         mAttribs.caption = caption;
 161         SDL_WM_SetCaption(caption.c_str(), 0);
 162 }
 163
 164 void Video::setIcon()
 165 {
 166         if (mAttribs.icon != "")
 167         {
 168                 Image icon(mAttribs.icon);
 169                 icon.setAsIcon();
 170         }
 171 }
 172
 173 std::string Video::getCaption() const
 174 {
 175         return mAttribs.caption;
 176 }
 177
 178 const std::string& Video::getIcon() const
 179 {
 180         return mAttribs.icon;
 181 }
 182
 183
 184 void Video::setFull(bool full)
 185 {
 186         if (full != isFull() || !mContext)
 187         {
 188                 if (mContext)
 189                 {
 190                         mFlags ^= SDL_FULLSCREEN;
 191
 192 #if defined(linux) || defined(__linux) || defined(__linux__)
 193                         if (SDL_WM_ToggleFullScreen(mContext) == 0)
 194 #endif
 195                         recreateContext();
 196                 }
 197                 else
 198                 {
 199                         if (full) mFlags |= SDL_FULLSCREEN;
 200                         else mFlags &= ~SDL_FULLSCREEN;
 201                 }
 202         }
 203 }
 204
 205 void Video::toggleFull()
 206 {
 207         setFull(!isFull());
 208 }
 209
 210 bool Video::isFull() const
 211 {
 212         return mFlags & SDL_FULLSCREEN;
 213 }
 214
 215
 216 void Video::setCursorVisible(bool hasCursor)
 217 {
 218         SDL_ShowCursor(hasCursor? SDL_ENABLE : SDL_DISABLE);
 219 }
 220
 221 void Video::toggleCursorVisible()
 222 {
 223         setCursorVisible(!isCursorVisible());
 224 }
 225
 226 bool Video::isCursorVisible() const
 227 {
 228         return (SDL_ShowCursor(SDL_QUERY) == SDL_ENABLE);
 229 }
 230
 231
 232 void Video::setResizable(bool resizable)
 233 {
 234         if (resizable != isResizable() || !mContext)
 235         {
 236                 if (mContext)
 237                 {
 238                         mFlags ^= SDL_RESIZABLE;
 239                         recreateContext();
 240                 }
 241                 else
 242                 {
 243                         if (resizable) mFlags |= SDL_RESIZABLE;
 244                         else mFlags &= ~SDL_RESIZABLE;
 245                 }
 246         }
 247 }
 248
 249 void Video::toggleResizable()
 250 {
 251         setResizable(!isResizable());
 252 }
 253
 254 bool Video::isResizable() const
 255 {
 256         return mFlags & SDL_RESIZABLE;
 257 }
 258
 259
 260 bool Video::isCursorGrab() const
 261 {
 262         return (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON);
 263 }
 264
 265 void Video::toggleCursorGrab()
 266 {
 267         setCursorGrab(!isCursorGrab());
 268 }
 269
 270 void Video::setCursorGrab(bool cursorGrab)
 271 {
 272         SDL_WM_GrabInput(cursorGrab? SDL_GRAB_ON : SDL_GRAB_OFF);
 273 }
 274
 275
 276 void Video::swap()
 277 {
 278         SDL_GL_SwapBuffers();
 279 }
 280
 281
 282 int Video::getWidth() const
 283 {
 284         return mContext->w;
 285 }
 286
 287 int Video::getHeight() const
 288 {
 289         return mContext->h;
 290 }
 291
 292
 293 Video::Attributes::Attributes()
 294 {
 295         // set some sane GL and window defaults (see SDL_video.c:217)
 296         colorBuffer[0] = 3;
 297         colorBuffer[1] = 3;
 298         colorBuffer[2] = 2;
 299         colorBuffer[3] = 0;
 300         frameBuffer = 0;
 301         doubleBuffer = true;
 302         depthBuffer = 16;
 303         stencilBuffer = 0;
 304         accumBuffer[0] = 0;
 305         accumBuffer[1] = 0;
 306         accumBuffer[2] = 0;
 307         accumBuffer[3] = 0;
 308         stereo = false;
 309         multisampleBuffers = 0;
 310         multisampleSamples = 0;
 311         swapControl = false;
 312         hardwareOnly = false;
 313         mode[0] = 640;
 314         mode[1] = 480;
 315         mode[2] = 0;
 316         fullscreen = false;
 317         resizable = false;
 318         cursorVisible = true;
 319         cursorGrab = false;
 320
 321         std::vector<long> colors;
 322         settings.get("colorbuffers", colors);
 323         if (colors.size() > 0) colorBuffer[0] = colors[0];
 324         if (colors.size() > 1) colorBuffer[1] = colors[1];
 325         if (colors.size() > 2) colorBuffer[2] = colors[2];
 326         if (colors.size() > 3) colorBuffer[3] = colors[3];
 327
 328         settings.get("framebuffer", frameBuffer);
 329         settings.get("doublebuffer", doubleBuffer);
 330         settings.get("depthbuffer", depthBuffer);
 331         settings.get("stencilbuffer", stencilBuffer);
 332
 333         std::vector<long> accum;
 334         settings.get("accumbuffers", accum);
 335         if (accum.size() > 0) accumBuffer[0] = accum[0];
 336         if (accum.size() > 1) accumBuffer[1] = accum[1];
 337         if (accum.size() > 2) accumBuffer[2] = accum[2];
 338         if (accum.size() > 3) accumBuffer[3] = accum[3];
 339
 340         settings.get("stereo", stereo);
 341         settings.get("multiesamplebuffers", multisampleBuffers);
 342         settings.get("multiesamplesamples", multisampleSamples);
 343         settings.get("swapcontrol", swapControl);
 344         settings.get("hardwareonly", hardwareOnly);
 345
 346         if (!settings.get("caption", caption))
 347         {
 348                 caption = "Untitled";
 349         }
 350         settings.get("icon", icon);
 351
 352         settings.get("fullscreen", fullscreen);
 353         settings.get("resizable", resizable);
 354         settings.get("showcursor", cursorVisible);
 355         settings.get("grab", cursorGrab);
 356
 357         std::vector<long> dimensions;
 358         settings.get("videomode", dimensions);
 359         if (dimensions.size() > 1)
 360         {
 361                 mode[0] = dimensions[0];
 362                 mode[1] = dimensions[1];
 363         }
 364         else if (fullscreen && Backend::isInitialized())
 365         {
 366                 SDL_Rect** modes = SDL_ListModes(NULL,
 367                                                                                  SDL_FULLSCREEN | SDL_HWSURFACE);
 368
 369                 if (modes == (SDL_Rect**)0)
 370                 {
 371                         Mf::logError("no native video mode");
 372                 }
 373                 else if (modes == (SDL_Rect**)-1)
 374                 {
 375                         Mf::logWarning("any resolution allowed; "
 376                                                    "choosing default 800x600");
 377                         mode[0] = 800;
 378                         mode[1] = 600;
 379                 }
 380                 else
 381                 {
 382                         mode[0] = (*modes)->w;
 383                         mode[1] = (*modes)->h;
 384                         Mf::logInfo << "choosing native resolution "
 385                                                 << mode[0] << "x" << mode[1] << std::endl;
 386                 }
 387         }
 388         if (dimensions.size() > 2) mode[2] = dimensions[2];
 389 }
 390
 391
 392 Video* video = 0;       // most recently instantiated instance
 393
 394
 395 } // namespace Mf
 396