+/*
+Copyright (C) 2003, 2010 - Wolfire Games
+
+This file is part of Lugaru.
+
+Lugaru 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 2
+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, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
+
#ifdef WIN32
#include <vld.h>
#endif
-#include "Game.h"
-
#ifndef USE_DEVIL
# ifdef WIN32
# define USE_DEVIL
#include "IL/il.h"
#include "IL/ilu.h"
#include "IL/ilut.h"
+ #include "Game.h"
#else
- // just use libpng and libjpg directly; it's lighter-weight and easier
- // to manage the dependencies on Linux...
+
extern "C" {
- #include "png.h"
- #include "jpeglib.h"
+ #include "zlib.h"
+ #include "png.h"
+ #include "jpeglib.h"
}
+ #include "Game.h"
static bool load_image(const char * fname, TGAImageRec & tex);
static bool load_png(const char * fname, TGAImageRec & tex);
static bool load_jpg(const char * fname, TGAImageRec & tex);
using namespace std;
+#if USE_SDL
+SDL_Rect **resolutions = NULL;
+static SDL_Rect rect_1024_768 = { 0, 0, 1024, 768 };
+static SDL_Rect rect_800_600 = { 0, 0, 800, 600 };
+static SDL_Rect rect_640_480 = { 0, 0, 640, 480 };
+static SDL_Rect *hardcoded_resolutions[] = {
+ &rect_1024_768,
+ &rect_800_600,
+ &rect_640_480,
+ NULL
+};
+#endif
+
+
unsigned int resolutionDepths[8][2] = {0};
bool selectDetail(int & width, int & height, int & bpp, int & detail);
char *arg = _argv[i];
while (*arg == '-')
arg++;
- if (stricmp(arg, cmd) == 0)
+ if (strcasecmp(arg, cmd) == 0)
return true;
}
static void sdlEventProc(const SDL_Event &e, Game &game)
{
int val;
+ bool skipkey = false;
SDLMod mod;
switch(e.type)
{
if (e.key.keysym.mod & KMOD_CTRL)
{
+ skipkey = true;
SDL_GrabMode mode = SDL_GRAB_ON;
if ((SDL_GetVideoSurface()->flags & SDL_FULLSCREEN) == 0)
{
else if (e.key.keysym.sym == SDLK_RETURN)
{
if (e.key.keysym.mod & KMOD_ALT)
+ {
+ skipkey = true;
SDL_WM_ToggleFullScreen(SDL_GetVideoSurface());
+ }
}
- if (e.key.keysym.sym < SDLK_LAST)
+ if ((!skipkey) && (e.key.keysym.sym < SDLK_LAST))
{
if (KeyTable[e.key.keysym.sym] != 0xffff)
SetKey(KeyTable[e.key.keysym.sym]);
SetKey(MAC_CONTROL_KEY);
if (mod & KMOD_ALT)
SetKey(MAC_OPTION_KEY);
+ if (mod & KMOD_META)
+ SetKey(MAC_COMMAND_KEY);
if (mod & KMOD_SHIFT)
SetKey(MAC_SHIFT_KEY);
if (mod & KMOD_CAPS)
if(detail>2)detail=2;
if(detail<0)detail=0;
- if(screenwidth>3000)screenwidth=640;
if(screenwidth<0)screenwidth=640;
- if(screenheight>3000)screenheight=480;
if(screenheight<0)screenheight=480;
+#if !USE_SDL // we'll take anything that works.
+ if(screenwidth>3000)screenwidth=640;
+ if(screenheight>3000)screenheight=480;
+#endif
}
if(kBitsPerPixel!=32&&kBitsPerPixel!=16){
kBitsPerPixel=16;
SDL_Quit();
return false;
}
+
+ SDL_Rect **res = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_OPENGL);
+ if ( (res == NULL) || (res == ((SDL_Rect **)-1)) || (res[0] == NULL) || (res[0]->w < 640) || (res[0]->h < 480) )
+ res = hardcoded_resolutions;
+
+ // reverse list (it was sorted biggest to smallest by SDL)...
+ int count;
+ for (count = 0; res[count]; count++)
+ {
+ if ((res[count]->w < 640) || (res[count]->h < 480))
+ break; // sane lower limit.
+ }
+
+ static SDL_Rect *resolutions_block = NULL;
+ resolutions_block = (SDL_Rect*) realloc(resolutions_block, sizeof (SDL_Rect) * count);
+ resolutions = (SDL_Rect**) realloc(resolutions, sizeof (SDL_Rect *) * (count + 1));
+ if ((resolutions_block == NULL) || (resolutions == NULL))
+ {
+ SDL_Quit();
+ fprintf(stderr, "Out of memory!\n");
+ return false;
+ }
+
+ resolutions[count--] = NULL;
+ for (int i = 0; count >= 0; i++, count--)
+ {
+ memcpy(&resolutions_block[count], res[i], sizeof (SDL_Rect));
+ resolutions[count] = &resolutions_block[count];
+ }
+
+ if (cmdline("showresolutions"))
+ {
+ printf("Resolutions we think are okay:\n");
+ for (int i = 0; resolutions[i]; i++)
+ printf(" %d x %d\n", (int) resolutions[i]->w, (int) resolutions[i]->h);
+ }
}
Uint32 sdlflags = SDL_OPENGL;
SDL_ShowCursor(0);
+ SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
if (SDL_SetVideoMode(kContextWidth, kContextHeight, 0, sdlflags) == NULL)
{
fprintf(stderr, "SDL_SetVideoMode() failed: %s\n", SDL_GetError());
+ fprintf(stderr, "forcing 640x480...\n");
+ kContextWidth = 640;
+ kContextHeight = 480;
+ if (SDL_SetVideoMode(kContextWidth, kContextHeight, 0, sdlflags) == NULL)
+ {
+ fprintf(stderr, "SDL_SetVideoMode() failed: %s\n", SDL_GetError());
+ fprintf(stderr, "forcing 640x480 windowed mode...\n");
+ sdlflags &= ~SDL_FULLSCREEN;
+ if (SDL_SetVideoMode(kContextWidth, kContextHeight, 0, sdlflags) == NULL)
+ {
+ fprintf(stderr, "SDL_SetVideoMode() failed: %s\n", SDL_GetError());
+ return false;
+ }
+ }
+ }
+
+ int dblbuf = 0;
+ if ((SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &dblbuf) == -1) || (!dblbuf))
+ {
+ fprintf(stderr, "Failed to get double buffered GL context!\n");
+ SDL_Quit();
return false;
}
char *retval;
char *envr;
- char *ptr = strrchr(argv0, '/');
+ char *ptr = strrchr((char *)argv0, '/');
if (strchr(argv0, '/'))
{
retval = strdup(argv0);
LOGFUNC;
#ifndef WIN32 // this is in WinMain, too.
- logger.start(true);
memset( &g_theKeys, 0, sizeof( KeyMap));
#endif
std::string e = "Caught exception: ";
e += error.what();
- LOG(e, Logger::LOG_ERR);
+ LOG(e);
MessageBox(g_windowHandle, error.what(), "ERROR", MB_OK | MB_ICONEXCLAMATION);
}
}
#endif
+#if !USE_SDL
int resolutionID(int width, int height)
{
int whichres;
return whichres;
}
+#endif
bool selectDetail(int & width, int & height, int & bpp, int & detail)
{
bool res = true;
+
+ // currently with SDL, we just use whatever is requested
+ // and don't care. --ryan.
+ #if !USE_SDL
int whichres = closestResolution(width, height);
while (true)
height=1200;
}
- // currently with SDL, we just use whatever the native bitdepth
- // of the display is and don't care.
- #if USE_SDL
- break;
- #endif
-
if ((detail != 0) && (resolutionDepths[whichres][1] != 0))
{
break;
}
bpp = resolutionDepths[whichres][(detail != 0)];
+ #endif
return res;
}
}
}
- logger.start(true);
-
memset( &g_theKeys, 0, sizeof( KeyMap));
unsigned int i = 0;
#if !USE_DEVIL
static bool load_image(const char *file_name, TGAImageRec &tex)
{
- char *ptr = strrchr(file_name, '.');
+ char *ptr = strrchr((char *)file_name, '.');
if (ptr)
{
- if (stricmp(ptr+1, "png") == 0)
+ if (strcasecmp(ptr+1, "png") == 0)
return load_png(file_name, tex);
- else if (stricmp(ptr+1, "jpg") == 0)
+ else if (strcasecmp(ptr+1, "jpg") == 0)
return load_jpg(file_name, tex);
}
png_init_io(png_ptr, fp);
png_read_png(png_ptr, info_ptr,
PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_PACKING,
- png_voidp_NULL);
+ NULL);
png_get_IHDR(png_ptr, info_ptr, &width, &height,
&bit_depth, &color_type, &interlace_type, NULL, NULL);
retval = true;
png_done:
- png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
+ png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
if (fp)
fclose(fp);
return (retval);
static bool save_image(const char *file_name)
{
- char *ptr = strrchr(file_name, '.');
+ char *ptr = strrchr((char *)file_name, '.');
if (ptr)
{
- if (stricmp(ptr+1, "png") == 0)
+ if (strcasecmp(ptr+1, "png") == 0)
return save_png(file_name);
}