#include "video/drawing_request.hpp"
#include "video/gl/gl_surface_data.hpp"
#include "video/gl/gl_texture.hpp"
+#include "video/util.hpp"
+
#define LIGHTMAP_DIV 5
#ifdef GL_VERSION_ES_CM_1_0
GLRenderer::GLRenderer() :
window(),
- desktop_size(-1, -1),
- screen_size(-1, -1),
+ glcontext(),
+ viewport(),
+ desktop_size(0, 0),
fullscreen_active(false),
last_texture(static_cast<GLuint> (-1))
{
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
- if(g_config->use_fullscreen)
- {
- apply_video_mode(g_config->fullscreen_size, true);
- }
- else
- {
- apply_video_mode(g_config->window_size, false);
- }
+ apply_video_mode();
// setup opengl state and transform
glDisable(GL_DEPTH_TEST);
// Init the projection matrix, viewport and stuff
apply_config();
-
+
if(texture_manager == 0)
texture_manager = new TextureManager();
else
texture_manager->reload_textures();
-
+
#ifndef GL_VERSION_ES_CM_1_0
GLenum err = glewInit();
if (GLEW_OK != err)
void
GLRenderer::draw_surface(const DrawingRequest& request)
{
- const Surface* surface = (const Surface*) request.request_data;
+ const Surface* surface = static_cast<const SurfaceRequest*>(request.request_data)->surface;
if(surface == NULL)
{
return;
void
GLRenderer::draw_gradient(const DrawingRequest& request)
{
- const GradientRequest* gradientrequest
+ const GradientRequest* gradientrequest
= (GradientRequest*) request.request_data;
const Color& top = gradientrequest->top;
const Color& bottom = gradientrequest->bottom;
glColor4f(fillrectrequest->color.red, fillrectrequest->color.green,
fillrectrequest->color.blue, fillrectrequest->color.alpha);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-
+
if (fillrectrequest->radius != 0.0f)
{
// draw round rect
// inner rectangle
Rectf irect(request.pos.x + radius,
- request.pos.y + radius,
- request.pos.x + fillrectrequest->size.x - radius,
- request.pos.y + fillrectrequest->size.y - radius);
+ request.pos.y + radius,
+ request.pos.x + fillrectrequest->size.x - radius,
+ request.pos.y + fillrectrequest->size.y - radius);
int n = 8;
int p = 0;
glDisable(GL_TEXTURE_2D);
glColor4f(ellipse->color.red, ellipse->color.green,
ellipse->color.blue, ellipse->color.alpha);
-
+
float x = request.pos.x;
float y = request.pos.y;
float w = ellipse->size.x/2.0f;
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
- glColor4f(1, 1, 1, 1);
+ glColor4f(1, 1, 1, 1);
}
-void
+void
GLRenderer::do_take_screenshot()
{
// [Christoph] TODO: Yes, this method also takes care of the actual disk I/O. Split it?
SDL_Surface *shot_surf;
// create surface to hold screenshot
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
- shot_surf = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, 24, 0x00FF0000, 0x0000FF00, 0x000000FF, 0);
+ shot_surf = SDL_CreateRGBSurface(0, SCREEN_WIDTH, SCREEN_HEIGHT, 24, 0x00FF0000, 0x0000FF00, 0x000000FF, 0);
#else
- shot_surf = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, 24, 0x000000FF, 0x0000FF00, 0x00FF0000, 0);
+ shot_surf = SDL_CreateRGBSurface(0, SCREEN_WIDTH, SCREEN_HEIGHT, 24, 0x000000FF, 0x0000FF00, 0x00FF0000, 0);
#endif
if (!shot_surf) {
log_warning << "Could not create RGB Surface to contain screenshot" << std::endl;
{
g_config->window_size = Size(w, h);
- PHYSICAL_SCREEN_WIDTH = w;
- PHYSICAL_SCREEN_HEIGHT = h;
-
apply_config();
}
void
GLRenderer::apply_config()
-{
- if (false)
- {
- log_info << "Applying Config:"
- << "\n Desktop: " << desktop_size.width << "x" << desktop_size.height
- << "\n Window: " << g_config->window_size
- << "\n FullRes: " << g_config->fullscreen_size
- << "\n Aspect: " << g_config->aspect_size
- << "\n Magnif: " << g_config->magnification
- << std::endl;
- }
-
- float target_aspect = static_cast<float>(desktop_size.width) / static_cast<float>(desktop_size.height);
- if (g_config->aspect_size != Size(0, 0))
- {
- target_aspect = float(g_config->aspect_size.width) / float(g_config->aspect_size.height);
- }
-
- float desktop_aspect = 4.0f / 3.0f; // random default fallback guess
- if (desktop_size.width != -1 && desktop_size.height != -1)
- {
- desktop_aspect = float(desktop_size.width) / float(desktop_size.height);
- }
-
- Size screen_size;
-
- // Get the screen width
- if (g_config->use_fullscreen)
- {
- screen_size = g_config->fullscreen_size;
- desktop_aspect = float(screen_size.width) / float(screen_size.height);
- }
- else
- {
- screen_size = g_config->window_size;
- }
+{
+ apply_video_mode();
- apply_video_mode(screen_size, g_config->use_fullscreen);
+ Size target_size = g_config->use_fullscreen ?
+ ((g_config->fullscreen_size == Size(0, 0)) ? desktop_size : g_config->fullscreen_size) :
+ g_config->window_size;
- if (target_aspect > 1.0f)
+ float pixel_aspect_ratio = 1.0f;
+ if (g_config->aspect_size != Size(0, 0))
{
- SCREEN_WIDTH = static_cast<int>(screen_size.width * (target_aspect / desktop_aspect));
- SCREEN_HEIGHT = static_cast<int>(screen_size.height);
+ pixel_aspect_ratio = calculate_pixel_aspect_ratio(desktop_size,
+ g_config->aspect_size);
}
- else
+ else if (g_config->use_fullscreen)
{
- SCREEN_WIDTH = static_cast<int>(screen_size.width);
- SCREEN_HEIGHT = static_cast<int>(screen_size.height * (target_aspect / desktop_aspect));
+ pixel_aspect_ratio = calculate_pixel_aspect_ratio(desktop_size,
+ target_size);
}
Size max_size(1280, 800);
Size min_size(640, 480);
- if (g_config->magnification == 0.0f) // Magic value that means 'minfill'
- {
- // This scales SCREEN_WIDTH/SCREEN_HEIGHT so that they never excede
- // max_size.width/max_size.height resp. min_size.width/min_size.height
- if (SCREEN_WIDTH > max_size.width || SCREEN_HEIGHT > max_size.height)
- {
- float scale1 = float(max_size.width)/SCREEN_WIDTH;
- float scale2 = float(max_size.height)/SCREEN_HEIGHT;
- float scale = (scale1 < scale2) ? scale1 : scale2;
- SCREEN_WIDTH = static_cast<int>(SCREEN_WIDTH * scale);
- SCREEN_HEIGHT = static_cast<int>(SCREEN_HEIGHT * scale);
- }
- else if (SCREEN_WIDTH < min_size.width || SCREEN_HEIGHT < min_size.height)
- {
- float scale1 = float(min_size.width)/SCREEN_WIDTH;
- float scale2 = float(min_size.height)/SCREEN_HEIGHT;
- float scale = (scale1 < scale2) ? scale1 : scale2;
- SCREEN_WIDTH = static_cast<int>(SCREEN_WIDTH * scale);
- SCREEN_HEIGHT = static_cast<int>(SCREEN_HEIGHT * scale);
- }
-
+ Vector scale;
+ Size logical_size;
+ calculate_viewport(min_size, max_size, target_size,
+ pixel_aspect_ratio,
+ g_config->magnification,
+ scale,
+ logical_size,
+ viewport);
- glViewport(0, 0, screen_size.width, screen_size.height);
- }
- else
- {
- SCREEN_WIDTH = static_cast<int>(SCREEN_WIDTH / g_config->magnification);
- SCREEN_HEIGHT = static_cast<int>(SCREEN_HEIGHT / g_config->magnification);
-
- // This works by adding black borders around the screen to limit
- // SCREEN_WIDTH/SCREEN_HEIGHT to max_size.width/max_size.height
- Size new_size = screen_size;
-
- if (SCREEN_WIDTH > max_size.width)
- {
- new_size.width = static_cast<int>((float) new_size.width * float(max_size.width)/SCREEN_WIDTH);
- SCREEN_WIDTH = static_cast<int>(max_size.width);
- }
-
- if (SCREEN_HEIGHT > max_size.height)
- {
- new_size.height = static_cast<int>((float) new_size.height * float(max_size.height)/SCREEN_HEIGHT);
- SCREEN_HEIGHT = static_cast<int>(max_size.height);
- }
+ SCREEN_WIDTH = logical_size.width;
+ SCREEN_HEIGHT = logical_size.height;
+ if (viewport.x != 0 || viewport.y != 0)
+ {
// Clear both buffers so that we get a clean black border without junk
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapWindow(window);
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapWindow(window);
-
- glViewport(std::max(0, (screen_size.width - new_size.width) / 2),
- std::max(0, (screen_size.height - new_size.height) / 2),
- std::min(new_size.width, screen_size.width),
- std::min(new_size.height, screen_size.height));
}
+ glViewport(viewport.x, viewport.y, viewport.w, viewport.h);
+
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
}
void
-GLRenderer::apply_video_mode(const Size& size, bool fullscreen)
+GLRenderer::apply_video_mode()
{
if (window)
{
- SDL_SetWindowSize(window, size.width, size.height);
-
- if (fullscreen)
+ if (!g_config->use_fullscreen)
{
- int fullscreen_flags = SDL_WINDOW_FULLSCREEN; // SDL_WINDOW_FULLSCREEN_DESKTOP or 0
- SDL_SetWindowDisplayMode(window, NULL);
-
- SDL_DisplayMode mode;
- mode.format = SDL_PIXELFORMAT_RGB888;
- mode.w = g_config->fullscreen_size.width;
- mode.h = g_config->fullscreen_size.height;
- mode.refresh_rate = g_config->fullscreen_refresh_rate;
- mode.driverdata = 0;
-
- if (SDL_SetWindowDisplayMode(window, &mode) != 0)
+ SDL_SetWindowFullscreen(window, 0);
+ }
+ else
+ {
+ if (g_config->fullscreen_size.width == 0 &&
+ g_config->fullscreen_size.height == 0)
{
- log_warning << "failed to set display mode: "
- << mode.w << "x" << mode.h << "@" << mode.refresh_rate << ": "
- << SDL_GetError() << std::endl;
+ if (SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP) != 0)
+ {
+ log_warning << "failed to switch to desktop fullscreen mode: "
+ << SDL_GetError() << std::endl;
+ }
+ else
+ {
+ log_info << "switched to desktop fullscreen mode" << std::endl;
+ }
}
else
{
- SDL_SetWindowFullscreen(window, fullscreen_flags);
+ SDL_DisplayMode mode;
+ mode.format = SDL_PIXELFORMAT_RGB888;
+ mode.w = g_config->fullscreen_size.width;
+ mode.h = g_config->fullscreen_size.height;
+ mode.refresh_rate = g_config->fullscreen_refresh_rate;
+ mode.driverdata = 0;
+
+ if (SDL_SetWindowDisplayMode(window, &mode) != 0)
+ {
+ log_warning << "failed to set display mode: "
+ << mode.w << "x" << mode.h << "@" << mode.refresh_rate << ": "
+ << SDL_GetError() << std::endl;
+ }
+ else
+ {
+ if (SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN) != 0)
+ {
+ log_warning << "failed to switch to fullscreen mode: "
+ << mode.w << "x" << mode.h << "@" << mode.refresh_rate << ": "
+ << SDL_GetError() << std::endl;
+ }
+ else
+ {
+ log_info << "switched to fullscreen mode: "
+ << mode.w << "x" << mode.h << "@" << mode.refresh_rate << std::endl;
+ }
+ }
}
}
- else
- {
- SDL_SetWindowFullscreen(window, 0);
- }
}
else
{
- int flags = SDL_WINDOW_OPENGL;
-
- if (fullscreen)
+ int flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
+ Size size;
+ if (g_config->use_fullscreen)
{
- flags |= SDL_WINDOW_FULLSCREEN;
+ if (g_config->fullscreen_size == Size(0, 0))
+ {
+ flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+ size = desktop_size;
+ }
+ else
+ {
+ flags |= SDL_WINDOW_FULLSCREEN;
+ size.width = g_config->fullscreen_size.width;
+ size.height = g_config->fullscreen_size.height;
+ }
}
else
{
- flags |= SDL_WINDOW_RESIZABLE;
+ size = g_config->window_size;
}
window = SDL_CreateWindow("SuperTux",
else
{
glcontext = SDL_GL_CreateContext(window);
- screen_size = size;
-
- PHYSICAL_SCREEN_WIDTH = size.width;
- PHYSICAL_SCREEN_HEIGHT = size.height;
SCREEN_WIDTH = size.width;
SCREEN_HEIGHT = size.height;
-
- fullscreen_active = fullscreen;
+
+ fullscreen_active = g_config->use_fullscreen;
}
}
}
Vector
-GLRenderer::to_logical(int physical_x, int physical_y, bool foobar)
+GLRenderer::to_logical(int physical_x, int physical_y)
{
- return Vector(physical_x * float(SCREEN_WIDTH) / PHYSICAL_SCREEN_WIDTH,
- physical_y * float(SCREEN_HEIGHT) / PHYSICAL_SCREEN_HEIGHT);
+ return Vector(static_cast<float>(physical_x - viewport.x) * SCREEN_WIDTH / viewport.w,
+ static_cast<float>(physical_y - viewport.y) * SCREEN_HEIGHT / viewport.h);
}
void
projects / supertux.git / blobdiff