int platform_init(int gles_version)
{
#ifdef FREMANTLE
SDL_GLES_Init(gles_version == 2 ? SDL_GLES_VERSION_2_0 : SDL_GLES_VERSION_1_1);
screen = SDL_SetVideoMode(0, 0, 0, SDL_FULLSCREEN);
SDL_GLES_MakeCurrent(SDL_GLES_CreateContext());
#else /* FREMANTLE */
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, gles_version);
screen = SDL_SetVideoMode(0, 0, 0, SDL_OPENGLES | SDL_FULLSCREEN);
#endif /* FREMANTLE */
if ( screen==NULL ) {
return 0;
}
#ifndef FREMANTLE
/* Set up swipe lock (left and right) */
SDL_SysWMinfo wm;
SDL_VERSION(&wm.version);
SDL_GetWMInfo(&wm);
Display *dpy = wm.info.x11.display;
Atom atom = XInternAtom(dpy, "_MEEGOTOUCH_CUSTOM_REGION", False);
unsigned int region[] = {
0,
MEEGOTOUCH_BORDER,
screen->w,
screen->h - 2*MEEGOTOUCH_BORDER,
};
XChangeProperty(dpy, wm.info.x11.wmwindow, atom, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*)region, 4);
#endif
return 1;
}
EAGLView::EAGLView()
{
d = new PrivateData;
/* this holds some info about our display */
const SDL_VideoInfo *videoInfo;
SDL_Init( SDL_INIT_VIDEO );
d->surface = SDL_SetVideoMode(0, 0, 16, SDL_SWSURFACE | SDL_FULLSCREEN);
SDL_ShowCursor(0);
SDL_WM_SetCaption("HexGame", "HexGame");
SDL_GLES_Init(SDL_GLES_VERSION_1_1);
SDL_GLES_Context *context = SDL_GLES_CreateContext();
SDL_GLES_MakeCurrent(context);
/* Enable smooth shading */
glShadeModel( GL_SMOOTH );
/* Set the background black */
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
/* Enables Depth Testing */
glEnable( GL_DEPTH_TEST );
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND_SRC);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
/* The Type Of Depth Test To Do */
glDepthFunc( GL_LEQUAL );
/* Really Nice Perspective Calculations */
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
/* Use of vertex arrays is mandatory in GLES */
glEnableClientState(GL_VERTEX_ARRAY);
resizeWindow( 800, 480 );
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
TextureCatalog* catalog = TextureCatalog::instance();
catalog->addAndLoad("units", loadTexture("texmap.png"), 2);
catalog->addAndLoad("hexTiles", loadTexture("texmap_hex.png"), 2);
catalog->addAndLoad("actions", loadTexture("actions.png"), 4);
catalog->addAndLoad("icons", loadTexture("icons.png"), 4);
d->centralControl = CentralControl::instance();
}
static int
fremantle_init(int gles_version)
{
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) < 0) {
return 0;
}
SDL_GLES_Init(gles_version == 2 ? SDL_GLES_VERSION_2_0 : SDL_GLES_VERSION_1_1);
SDL_GLES_SetAttribute(SDL_GLES_DEPTH_SIZE, 16);
priv.screen = SDL_SetVideoMode(0, 0, 0, SDL_FULLSCREEN);
SDL_GLES_MakeCurrent(SDL_GLES_CreateContext());
if (priv.screen == NULL) {
return 0;
}
SDL_ShowCursor(0);
apkenv_accelerometer_register(n900_accelerometer);
apkenv_audio_register(sdl_audio);
apkenv_mixer_register(sdl_mixer);
return 1;
}
/**
** Initialize the video part for SDL.
*/
void InitVideoSdl()
{
Uint32 flags = 0;
if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
#ifndef USE_WIN32
// Fix tablet input in full-screen mode
SDL_putenv(strdup("SDL_MOUSE_RELATIVE=0"));
#endif
int res = SDL_Init(
#ifdef DEBUG
SDL_INIT_NOPARACHUTE |
#endif
SDL_INIT_AUDIO | SDL_INIT_VIDEO |
SDL_INIT_TIMER);
if (res < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
// Clean up on exit
atexit(SDL_Quit);
#ifdef USE_MAEMO
maemo_init();
#endif
// If debug is enabled, Stratagus disable SDL Parachute.
// So we need gracefully handle segfaults and aborts.
#if defined(DEBUG) && !defined(USE_WIN32)
signal(SIGSEGV, CleanExit);
signal(SIGABRT, CleanExit);
#endif
// Set WindowManager Title
if (!FullGameName.empty()) {
SDL_WM_SetCaption(FullGameName.c_str(), FullGameName.c_str());
} else if (!Parameters::Instance.applicationName.empty()) {
SDL_WM_SetCaption(Parameters::Instance.applicationName.c_str(), Parameters::Instance.applicationName.c_str());
} else {
SDL_WM_SetCaption("Stratagus", "Stratagus");
}
#if ! defined(USE_WIN32) && ! defined(USE_MAEMO)
#if defined(USE_OPENGL) || defined(USE_GLES)
// Make sure, that we not create OpenGL textures (and do not call OpenGL functions), when creating icon surface
bool UseOpenGL_orig = UseOpenGL;
UseOpenGL = false;
#endif
SDL_Surface *icon = NULL;
CGraphic *g = NULL;
struct stat st;
std::string FullGameNameL = FullGameName;
for (size_t i = 0; i < FullGameNameL.size(); ++i) {
FullGameNameL[i] = tolower(FullGameNameL[i]);
}
std::string ApplicationName = Parameters::Instance.applicationName;
std::string ApplicationNameL = ApplicationName;
for (size_t i = 0; i < ApplicationNameL.size(); ++i) {
ApplicationNameL[i] = tolower(ApplicationNameL[i]);
}
std::vector <std::string> pixmaps;
pixmaps.push_back(std::string() + PIXMAPS + "/" + FullGameName + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + FullGameNameL + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + FullGameName + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + FullGameNameL + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + ApplicationName + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + ApplicationNameL + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + ApplicationName + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + ApplicationNameL + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + "Stratagus" + ".png");
pixmaps.push_back(std::string() + PIXMAPS + "/" + "stratagus" + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + "Stratagus" + ".png");
pixmaps.push_back(std::string() + "/usr/share/pixmaps" + "/" + "stratagus" + ".png");
for (size_t i = 0; i < pixmaps.size(); ++i) {
if (stat(pixmaps[i].c_str(), &st) == 0) {
if (g) { CGraphic::Free(g); }
g = CGraphic::New(pixmaps[i].c_str());
g->Load();
icon = g->Surface;
if (icon) { break; }
}
}
if (icon) {
SDL_WM_SetIcon(icon, 0);
}
if (g) {
CGraphic::Free(g);
}
#if defined(USE_OPENGL) || defined(USE_GLES)
UseOpenGL = UseOpenGL_orig;
#endif
#endif
#ifdef USE_WIN32
HWND hwnd = NULL;
HICON hicon = NULL;
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if (SDL_GetWMInfo(&info)) {
hwnd = info.window;
}
if (hwnd) {
hicon = ExtractIcon(GetModuleHandle(NULL), Parameters::Instance.applicationName.c_str(), 0);
}
if (hicon) {
SendMessage(hwnd, (UINT)WM_SETICON, ICON_SMALL, (LPARAM)hicon);
SendMessage(hwnd, (UINT)WM_SETICON, ICON_BIG, (LPARAM)hicon);
}
#endif
}
// Initialize the display
#ifdef USE_MAEMO
// TODO: Support window mode and portrait mode resolution on Maemo - Nokia N900
Video.FullScreen = 1;
Video.Width = 800;
Video.Height = 480;
#endif
#if !defined(USE_OPENGL) && !defined(USE_GLES)
flags = SDL_HWSURFACE | SDL_HWPALETTE;
#endif
// Sam said: better for windows.
/* SDL_HWSURFACE|SDL_HWPALETTE | */
if (Video.FullScreen) {
flags |= SDL_FULLSCREEN;
}
#if defined(USE_OPENGL) || defined(USE_GLES)
if (UseOpenGL) {
#ifdef USE_GLES_NATIVE
flags |= SDL_OPENGLES;
#endif
#ifdef USE_GLES_MAEMO
if (SDL_GLES_Init(SDL_GLES_VERSION_1_1) < 0) {
fprintf(stderr, "Couldn't initialize SDL_GLES: %s\n", SDL_GetError());
exit(1);
}
// Clean up GLES on exit
atexit(SDL_GLES_Quit);
flags |= SDL_SWSURFACE;
#endif
#ifdef USE_OPENGL
flags |= SDL_OPENGL | SDL_GL_DOUBLEBUFFER;
#endif
}
#endif
if (!Video.Width || !Video.Height) {
Video.Width = 640;
Video.Height = 480;
}
if (!Video.Depth) {
Video.Depth = 32;
}
#if defined(USE_OPENGL) || defined(USE_GLES)
if (!Video.ViewportWidth || !Video.ViewportHeight) {
Video.ViewportWidth = Video.Width;
Video.ViewportHeight = Video.Height;
}
TheScreen = SDL_SetVideoMode(Video.ViewportWidth, Video.ViewportHeight, Video.Depth, flags);
#else
TheScreen = SDL_SetVideoMode(Video.Width, Video.Height, Video.Depth, flags);
#endif
if (TheScreen && (TheScreen->format->BitsPerPixel != 16
&& TheScreen->format->BitsPerPixel != 32)) {
// Only support 16 and 32 bpp, default to 16
#if defined(USE_OPENGL) || defined(USE_GLES)
TheScreen = SDL_SetVideoMode(Video.ViewportWidth, Video.ViewportHeight, 16, flags);
#else
TheScreen = SDL_SetVideoMode(Video.Width, Video.Height, 16, flags);
#endif
}
if (TheScreen == NULL) {
fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
Video.Width, Video.Height, Video.Depth, SDL_GetError());
exit(1);
}
Video.FullScreen = (TheScreen->flags & SDL_FULLSCREEN) ? 1 : 0;
Video.Depth = TheScreen->format->BitsPerPixel;
#if defined(USE_TOUCHSCREEN) && defined(USE_WIN32)
// Must not allow SDL to switch to relative mouse coordinates
// with touchscreen when going fullscreen. So we don't hide the
// cursor, but instead set a transparent 1px cursor
Uint8 emptyCursor[] = {'\0'};
Video.blankCursor = SDL_CreateCursor(emptyCursor, emptyCursor, 1, 1, 0, 0);
SDL_SetCursor(Video.blankCursor);
#else
// Turn cursor off, we use our own.
SDL_ShowCursor(SDL_DISABLE);
#endif
// Make default character translation easier
SDL_EnableUNICODE(1);
#if defined(USE_OPENGL) || defined(USE_GLES)
if (UseOpenGL) {
#ifdef USE_GLES_MAEMO
SDL_GLES_Context *context = SDL_GLES_CreateContext();
if (!context) {
fprintf(stderr, "Couldn't initialize SDL_GLES_CreateContext: %s\n", SDL_GetError());
exit(1);
}
if (SDL_GLES_MakeCurrent(context) < 0) {
fprintf(stderr, "Couldn't initialize SDL_GLES_MakeCurrent: %s\n", SDL_GetError());
exit(1);
}
// atexit(GLES_DeleteContext(context));
#endif
#ifdef USE_GLES_EGL
// Get the SDL window handle
SDL_SysWMinfo sysInfo; //Will hold our Window information
SDL_VERSION(&sysInfo.version); //Set SDL version
if (SDL_GetWMInfo(&sysInfo) <= 0) {
fprintf(stderr, "Unable to get window handle\n");
exit(1);
}
eglDisplay = eglGetDisplay((EGLNativeDisplayType)sysInfo.info.x11.display);
if (!eglDisplay) {
fprintf(stderr, "Couldn't open EGL Display\n");
exit(1);
}
if (!eglInitialize(eglDisplay, NULL, NULL)) {
fprintf(stderr, "Couldn't initialize EGL Display\n");
exit(1);
}
// Find a matching config
EGLint configAttribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE};
EGLint numConfigsOut = 0;
EGLConfig eglConfig;
if (eglChooseConfig(eglDisplay, configAttribs, &eglConfig, 1, &numConfigsOut) != EGL_TRUE || numConfigsOut == 0) {
fprintf(stderr, "Unable to find appropriate EGL config\n");
exit(1);
}
eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, (EGLNativeWindowType)sysInfo.info.x11.window, 0);
if (eglSurface == EGL_NO_SURFACE) {
fprintf(stderr, "Unable to create EGL surface\n");
exit(1);
}
// Bind GLES and create the context
eglBindAPI(EGL_OPENGL_ES_API);
EGLint contextParams[] = {EGL_CONTEXT_CLIENT_VERSION, 1, EGL_NONE};
EGLContext eglContext = eglCreateContext(eglDisplay, eglConfig, NULL, NULL);
if (eglContext == EGL_NO_CONTEXT) {
fprintf(stderr, "Unable to create GLES context\n");
exit(1);
}
if (eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) == EGL_FALSE) {
fprintf(stderr, "Unable to make GLES context current\n");
exit(1);
}
#endif
InitOpenGL();
}
#endif
InitKey2Str();
ColorBlack = Video.MapRGB(TheScreen->format, 0, 0, 0);
ColorDarkGreen = Video.MapRGB(TheScreen->format, 48, 100, 4);
ColorLightBlue = Video.MapRGB(TheScreen->format, 52, 113, 166);
ColorBlue = Video.MapRGB(TheScreen->format, 0, 0, 252);
ColorOrange = Video.MapRGB(TheScreen->format, 248, 140, 20);
ColorWhite = Video.MapRGB(TheScreen->format, 252, 248, 240);
ColorLightGray = Video.MapRGB(TheScreen->format, 192, 192, 192);
ColorGray = Video.MapRGB(TheScreen->format, 128, 128, 128);
ColorDarkGray = Video.MapRGB(TheScreen->format, 64, 64, 64);
ColorRed = Video.MapRGB(TheScreen->format, 252, 0, 0);
ColorGreen = Video.MapRGB(TheScreen->format, 0, 252, 0);
ColorYellow = Video.MapRGB(TheScreen->format, 252, 252, 0);
UI.MouseWarpPos.x = UI.MouseWarpPos.y = -1;
}