Added rendermax plugin- a bunch of rendering hax in one. Small fix to skeleton.
Warmist
parent
64ff24f27f
commit
dec0b202ee
@ -0,0 +1,39 @@
|
|||||||
|
PROJECT (rendermax)
|
||||||
|
Find_Package(SDL REQUIRED)
|
||||||
|
find_package(OpenGL REQUIRED)
|
||||||
|
find_package(GLUT REQUIRED)
|
||||||
|
# A list of source files
|
||||||
|
SET(PROJECT_SRCS
|
||||||
|
rendermax.cpp
|
||||||
|
)
|
||||||
|
# A list of headers
|
||||||
|
SET(PROJECT_HDRS
|
||||||
|
renderer_opengl.hpp
|
||||||
|
)
|
||||||
|
SET_SOURCE_FILES_PROPERTIES( ${PROJECT_HDRS} PROPERTIES HEADER_FILE_ONLY TRUE)
|
||||||
|
|
||||||
|
# mash them together (headers are marked as headers and nothing will try to compile them)
|
||||||
|
LIST(APPEND PROJECT_SRCS ${PROJECT_HDRS})
|
||||||
|
include_directories(${SDL_INCLUDE_DIR})
|
||||||
|
|
||||||
|
#linux
|
||||||
|
IF(UNIX)
|
||||||
|
add_definitions(-DLINUX_BUILD)
|
||||||
|
SET(PROJECT_LIBS
|
||||||
|
# add any extra linux libs here
|
||||||
|
${SDL_LIBRARY}
|
||||||
|
opengl
|
||||||
|
${PROJECT_LIBS}
|
||||||
|
)
|
||||||
|
# windows
|
||||||
|
ELSE(UNIX)
|
||||||
|
SET(PROJECT_LIBS
|
||||||
|
# add any extra windows libs here
|
||||||
|
${SDL_LIBRARY}
|
||||||
|
opengl
|
||||||
|
${PROJECT_LIBS}
|
||||||
|
$(NOINHERIT)
|
||||||
|
)
|
||||||
|
ENDIF(UNIX)
|
||||||
|
# this makes sure all the stuff is put in proper places and linked to dfhack
|
||||||
|
DFHACK_PLUGIN(rendermax ${PROJECT_SRCS} LINK_LIBRARIES ${PROJECT_LIBS})
|
||||||
@ -0,0 +1,658 @@
|
|||||||
|
//original file from https://github.com/Baughn/Dwarf-Fortress--libgraphics-
|
||||||
|
#include "Core.h"
|
||||||
|
#include <VTableInterpose.h>
|
||||||
|
#include "df/renderer.h"
|
||||||
|
#include "df/init.h"
|
||||||
|
#include "df/enabler.h"
|
||||||
|
#include "df/zoom_commands.h"
|
||||||
|
#include "df/texture_handler.h"
|
||||||
|
|
||||||
|
using df::renderer;
|
||||||
|
using df::init;
|
||||||
|
using df::enabler;
|
||||||
|
|
||||||
|
#include "SDL.h"
|
||||||
|
|
||||||
|
#ifdef __APPLE__
|
||||||
|
#include <OpenGL/gl.h>
|
||||||
|
#include <OpenGL/glu.h>
|
||||||
|
//#include <GLUT/glut.h>
|
||||||
|
#else
|
||||||
|
#ifdef _WIN32
|
||||||
|
#include <windows.h>
|
||||||
|
#endif
|
||||||
|
#include <GL/gl.h>
|
||||||
|
#include <GL/glu.h>
|
||||||
|
//#include <GL/glut.h>
|
||||||
|
#endif
|
||||||
|
bool isFullscreen()
|
||||||
|
{
|
||||||
|
return df::global::enabler->fullscreen;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename L, typename R>
|
||||||
|
struct Either {
|
||||||
|
bool isL;
|
||||||
|
union {
|
||||||
|
L left;
|
||||||
|
R right;
|
||||||
|
};
|
||||||
|
Either(const L &l) {
|
||||||
|
isL = true;
|
||||||
|
left = l;
|
||||||
|
}
|
||||||
|
Either(const R &r) {
|
||||||
|
isL = false;
|
||||||
|
right = r;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// STANDARD
|
||||||
|
class renderer_opengl : public renderer {
|
||||||
|
public:
|
||||||
|
virtual bool uses_opengl() { return true; }
|
||||||
|
|
||||||
|
protected:
|
||||||
|
SDL_Surface *screen;
|
||||||
|
|
||||||
|
int dispx, dispy; // Cache of the current font size
|
||||||
|
|
||||||
|
bool init_video(int w, int h) {
|
||||||
|
// Get ourselves an opengl-enabled SDL window
|
||||||
|
uint32_t flags = SDL_HWSURFACE | SDL_OPENGL;
|
||||||
|
|
||||||
|
// Set it up for windowed or fullscreen, depending.
|
||||||
|
if (isFullscreen()) {
|
||||||
|
flags |= SDL_FULLSCREEN;
|
||||||
|
} else {
|
||||||
|
if (!df::global::init->display.flag.is_set(INIT_DISPLAY_FLAG_NOT_RESIZABLE))
|
||||||
|
flags |= SDL_RESIZABLE;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Setup OpenGL attributes
|
||||||
|
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, init.window.flag.has_flag(INIT_WINDOW_FLAG_VSYNC_ON));
|
||||||
|
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,
|
||||||
|
init.display.flag.has_flag(INIT_DISPLAY_FLAG_SINGLE_BUFFER) ? 0 : 1);
|
||||||
|
|
||||||
|
// (Re)create the window
|
||||||
|
screen = SDL_SetVideoMode(w, h, 32, flags);
|
||||||
|
|
||||||
|
if (!screen) return false;
|
||||||
|
|
||||||
|
// Test double-buffering status
|
||||||
|
int test;
|
||||||
|
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &test);
|
||||||
|
if (test != ((init.display.flag.has_flag(INIT_DISPLAY_FLAG_SINGLE_BUFFER)) ? 0 : 1)) {
|
||||||
|
if (isFullscreen());
|
||||||
|
//errorlog << "Requested single-buffering not available\n" << flush;
|
||||||
|
else
|
||||||
|
report_error("OpenGL", "Requested single-buffering not available");
|
||||||
|
}
|
||||||
|
|
||||||
|
// (Re)initialize GLEW. Technically only needs to be done once on
|
||||||
|
// linux, but on windows forgetting will cause crashes.
|
||||||
|
glewInit();
|
||||||
|
|
||||||
|
// Set the viewport and clear
|
||||||
|
glViewport(0, 0, screen->w, screen->h);
|
||||||
|
glClear(GL_COLOR_BUFFER_BIT);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Vertexes, foreground color, background color, texture coordinates
|
||||||
|
GLfloat *vertexes, *fg, *bg, *tex;
|
||||||
|
|
||||||
|
void write_tile_vertexes(GLfloat x, GLfloat y, GLfloat *vertex) {
|
||||||
|
vertex[0] = x; // Upper left
|
||||||
|
vertex[1] = y;
|
||||||
|
vertex[2] = x+1; // Upper right
|
||||||
|
vertex[3] = y;
|
||||||
|
vertex[4] = x; // Lower left
|
||||||
|
vertex[5] = y+1;
|
||||||
|
vertex[6] = x; // Lower left again (triangle 2)
|
||||||
|
vertex[7] = y+1;
|
||||||
|
vertex[8] = x+1; // Upper right
|
||||||
|
vertex[9] = y;
|
||||||
|
vertex[10] = x+1; // Lower right
|
||||||
|
vertex[11] = y+1;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void allocate(int tiles) {
|
||||||
|
vertexes = static_cast<GLfloat*>(realloc(vertexes, sizeof(GLfloat) * tiles * 2 * 6));
|
||||||
|
assert(vertexes);
|
||||||
|
fg = static_cast<GLfloat*>(realloc(fg, sizeof(GLfloat) * tiles * 4 * 6));
|
||||||
|
assert(fg);
|
||||||
|
bg = static_cast<GLfloat*>(realloc(bg, sizeof(GLfloat) * tiles * 4 * 6));
|
||||||
|
assert(bg);
|
||||||
|
tex = static_cast<GLfloat*>(realloc(tex, sizeof(GLfloat) * tiles * 2 * 6));
|
||||||
|
assert(tex);
|
||||||
|
|
||||||
|
glEnableClientState(GL_VERTEX_ARRAY);
|
||||||
|
glVertexPointer(2, GL_FLOAT, 0, vertexes);
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void init_opengl() {
|
||||||
|
//enabler.textures.upload_textures();
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void uninit_opengl() {
|
||||||
|
//enabler.textures.remove_uploaded_textures();
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void draw(int vertex_count) {
|
||||||
|
// Render the background colors
|
||||||
|
glDisable(GL_TEXTURE_2D);
|
||||||
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||||
|
glDisable(GL_BLEND);
|
||||||
|
glDisable(GL_ALPHA_TEST);
|
||||||
|
glColorPointer(4, GL_FLOAT, 0, bg);
|
||||||
|
glDrawArrays(GL_TRIANGLES, 0, vertex_count);
|
||||||
|
// Render the foreground, colors and textures both
|
||||||
|
glEnable(GL_ALPHA_TEST);
|
||||||
|
glAlphaFunc(GL_NOTEQUAL, 0);
|
||||||
|
glEnable(GL_TEXTURE_2D);
|
||||||
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||||
|
glEnable(GL_BLEND);
|
||||||
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||||
|
glTexCoordPointer(2, GL_FLOAT, 0, tex);
|
||||||
|
glColorPointer(4, GL_FLOAT, 0, fg);
|
||||||
|
glDrawArrays(GL_TRIANGLES, 0, vertex_count);
|
||||||
|
|
||||||
|
printGLError();
|
||||||
|
}
|
||||||
|
|
||||||
|
void write_tile_arrays(int x, int y, GLfloat *fg, GLfloat *bg, GLfloat *tex) {
|
||||||
|
Either<texture_fullid,texture_ttfid> id = screen_to_texid(x, y);
|
||||||
|
if (id.isL) { // An ordinary tile
|
||||||
|
const gl_texpos *txt = df::global::enabler->textures.gl_texpos;
|
||||||
|
// TODO: Only bother to set the one that's actually read in flat-shading mode
|
||||||
|
// And set flat-shading mode.
|
||||||
|
for (int i = 0; i < 6; i++) {
|
||||||
|
*(fg++) = id.left.r;
|
||||||
|
*(fg++) = id.left.g;
|
||||||
|
*(fg++) = id.left.b;
|
||||||
|
*(fg++) = 1;
|
||||||
|
|
||||||
|
*(bg++) = id.left.br;
|
||||||
|
*(bg++) = id.left.bg;
|
||||||
|
*(bg++) = id.left.bb;
|
||||||
|
*(bg++) = 1;
|
||||||
|
}
|
||||||
|
// Set texture coordinates
|
||||||
|
*(tex++) = txt[id.left.texpos].left; // Upper left
|
||||||
|
*(tex++) = txt[id.left.texpos].bottom;
|
||||||
|
*(tex++) = txt[id.left.texpos].right; // Upper right
|
||||||
|
*(tex++) = txt[id.left.texpos].bottom;
|
||||||
|
*(tex++) = txt[id.left.texpos].left; // Lower left
|
||||||
|
*(tex++) = txt[id.left.texpos].top;
|
||||||
|
|
||||||
|
*(tex++) = txt[id.left.texpos].left; // Lower left
|
||||||
|
*(tex++) = txt[id.left.texpos].top;
|
||||||
|
*(tex++) = txt[id.left.texpos].right; // Upper right
|
||||||
|
*(tex++) = txt[id.left.texpos].bottom;
|
||||||
|
*(tex++) = txt[id.left.texpos].right; // Lower right
|
||||||
|
*(tex++) = txt[id.left.texpos].top;
|
||||||
|
} else {
|
||||||
|
// TODO
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
void update_tile(int x, int y) {
|
||||||
|
const int tile = x*gps.dimy + y;
|
||||||
|
// Update the arrays
|
||||||
|
GLfloat *fg = this->fg + tile * 4 * 6;
|
||||||
|
GLfloat *bg = this->bg + tile * 4 * 6;
|
||||||
|
GLfloat *tex = this->tex + tile * 2 * 6;
|
||||||
|
write_tile_arrays(x, y, fg, bg, tex);
|
||||||
|
}
|
||||||
|
|
||||||
|
void update_all() {
|
||||||
|
glClear(GL_COLOR_BUFFER_BIT);
|
||||||
|
for (int x = 0; x < gps.dimx; x++)
|
||||||
|
for (int y = 0; y < gps.dimy; y++)
|
||||||
|
update_tile(x, y);
|
||||||
|
}
|
||||||
|
|
||||||
|
void render() {
|
||||||
|
draw(gps.dimx*gps.dimy*6);
|
||||||
|
if (init.display.flag.has_flag(INIT_DISPLAY_FLAG_ARB_SYNC) && GL_ARB_sync) {
|
||||||
|
assert(df::global::enabler->sync == NULL);
|
||||||
|
df::global::enabler->sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
|
||||||
|
}
|
||||||
|
SDL_GL_SwapBuffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
renderer_opengl() {
|
||||||
|
// Init member variables so realloc'll work
|
||||||
|
screen = NULL;
|
||||||
|
vertexes = NULL;
|
||||||
|
fg = NULL;
|
||||||
|
bg = NULL;
|
||||||
|
tex = NULL;
|
||||||
|
zoom_steps = forced_steps = 0;
|
||||||
|
|
||||||
|
// Disable key repeat
|
||||||
|
SDL_EnableKeyRepeat(0, 0);
|
||||||
|
// Set window title/icon.
|
||||||
|
SDL_WM_SetCaption(GAME_TITLE_STRING, NULL);
|
||||||
|
SDL_Surface *icon = IMG_Load("data/art/icon.png");
|
||||||
|
if (icon != NULL) {
|
||||||
|
SDL_WM_SetIcon(icon, NULL);
|
||||||
|
// The icon's surface doesn't get used past this point.
|
||||||
|
SDL_FreeSurface(icon);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find the current desktop resolution if fullscreen resolution is auto
|
||||||
|
if (init.display.desired_fullscreen_width == 0 ||
|
||||||
|
init.display.desired_fullscreen_height == 0) {
|
||||||
|
const struct SDL_VideoInfo *info = SDL_GetVideoInfo();
|
||||||
|
init.display.desired_fullscreen_width = info->current_w;
|
||||||
|
init.display.desired_fullscreen_height = info->current_h;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initialize our window
|
||||||
|
bool worked = init_video(isFullscreen() ?
|
||||||
|
init.display.desired_fullscreen_width :
|
||||||
|
init.display.desired_windowed_width,
|
||||||
|
isFullscreen() ?
|
||||||
|
init.display.desired_fullscreen_height :
|
||||||
|
init.display.desired_windowed_height);
|
||||||
|
|
||||||
|
// Fallback to windowed mode if fullscreen fails
|
||||||
|
if (!worked && isFullscreen()) {
|
||||||
|
df::global::enabler->fullscreen = false;
|
||||||
|
report_error("SDL initialization failure, trying windowed mode", SDL_GetError());
|
||||||
|
worked = init_video(init.display.desired_windowed_width,
|
||||||
|
init.display.desired_windowed_height);
|
||||||
|
}
|
||||||
|
// Quit if windowed fails
|
||||||
|
if (!worked) {
|
||||||
|
report_error("SDL initialization failure", SDL_GetError());
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initialize opengl
|
||||||
|
init_opengl();
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual ~renderer_opengl() {
|
||||||
|
free(vertexes);
|
||||||
|
free(fg);
|
||||||
|
free(bg);
|
||||||
|
free(tex);
|
||||||
|
}
|
||||||
|
|
||||||
|
int zoom_steps, forced_steps;
|
||||||
|
int natural_w, natural_h; // How large our view would be if it wasn't zoomed
|
||||||
|
|
||||||
|
void zoom(df::zoom_commands cmd) {
|
||||||
|
pair<int,int> before = compute_zoom(true);
|
||||||
|
int before_steps = zoom_steps;
|
||||||
|
switch (cmd) {
|
||||||
|
case zoom_in: zoom_steps -= init.input.zoom_speed; break;
|
||||||
|
case zoom_out: zoom_steps += init.input.zoom_speed; break;
|
||||||
|
case zoom_reset:
|
||||||
|
zoom_steps = 0;
|
||||||
|
case zoom_resetgrid:
|
||||||
|
compute_forced_zoom();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
pair<int,int> after = compute_zoom(true);
|
||||||
|
if (after == before && (cmd == zoom_in || cmd == zoom_out))
|
||||||
|
zoom_steps = before_steps;
|
||||||
|
else
|
||||||
|
reshape(after);
|
||||||
|
}
|
||||||
|
|
||||||
|
void compute_forced_zoom() {
|
||||||
|
forced_steps = 0;
|
||||||
|
pair<int,int> zoomed = compute_zoom();
|
||||||
|
while (zoomed.first < MIN_GRID_X || zoomed.second < MIN_GRID_Y) {
|
||||||
|
forced_steps++;
|
||||||
|
zoomed = compute_zoom();
|
||||||
|
}
|
||||||
|
while (zoomed.first > MAX_GRID_X || zoomed.second > MAX_GRID_Y) {
|
||||||
|
forced_steps--;
|
||||||
|
zoomed = compute_zoom();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pair<int,int> compute_zoom(bool clamp = false) {
|
||||||
|
const int dispx = isFullscreen() ?
|
||||||
|
init.font.large_font_dispx :
|
||||||
|
init.font.small_font_dispx;
|
||||||
|
const int dispy = isFullscreen() ?
|
||||||
|
init.font.large_font_dispy :
|
||||||
|
init.font.small_font_dispy;
|
||||||
|
int w, h;
|
||||||
|
if (dispx < dispy) {
|
||||||
|
w = natural_w + zoom_steps + forced_steps;
|
||||||
|
h = double(natural_h) * (double(w) / double(natural_w));
|
||||||
|
} else {
|
||||||
|
h = natural_h + zoom_steps + forced_steps;
|
||||||
|
w = double(natural_w) * (double(h) / double(natural_h));
|
||||||
|
}
|
||||||
|
if (clamp) {
|
||||||
|
w = MIN(MAX(w, MIN_GRID_X), MAX_GRID_X);
|
||||||
|
h = MIN(MAX(h, MIN_GRID_Y), MAX_GRID_Y);
|
||||||
|
}
|
||||||
|
return make_pair(w,h);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parameters: grid units
|
||||||
|
void reshape(pair<int,int> size) {
|
||||||
|
int w = MIN(MAX(size.first, MIN_GRID_X), MAX_GRID_X);
|
||||||
|
int h = MIN(MAX(size.second, MIN_GRID_Y), MAX_GRID_Y);
|
||||||
|
#ifdef DEBUG
|
||||||
|
cout << "Resizing grid to " << w << "x" << h << endl;
|
||||||
|
#endif
|
||||||
|
gps_allocate(w, h);
|
||||||
|
reshape_gl();
|
||||||
|
}
|
||||||
|
|
||||||
|
int off_x, off_y, size_x, size_y;
|
||||||
|
|
||||||
|
bool get_mouse_coords(int &x, int &y) {
|
||||||
|
int mouse_x, mouse_y;
|
||||||
|
SDL_GetMouseState(&mouse_x, &mouse_y);
|
||||||
|
mouse_x -= off_x; mouse_y -= off_y;
|
||||||
|
if (mouse_x < 0 || mouse_y < 0 ||
|
||||||
|
mouse_x >= size_x || mouse_y >= size_y)
|
||||||
|
return false; // Out of bounds
|
||||||
|
x = double(mouse_x) / double(size_x) * double(gps.dimx);
|
||||||
|
y = double(mouse_y) / double(size_y) * double(gps.dimy);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void reshape_gl() {
|
||||||
|
// Allocate array memory
|
||||||
|
allocate(gps.dimx * gps.dimy);
|
||||||
|
// Initialize the vertex array
|
||||||
|
int tile = 0;
|
||||||
|
for (GLfloat x = 0; x < gps.dimx; x++)
|
||||||
|
for (GLfloat y = 0; y < gps.dimy; y++, tile++)
|
||||||
|
write_tile_vertexes(x, y, vertexes + 6*2*tile);
|
||||||
|
// Setup invariant state
|
||||||
|
glEnableClientState(GL_COLOR_ARRAY);
|
||||||
|
/// Set up our coordinate system
|
||||||
|
if (forced_steps + zoom_steps == 0 &&
|
||||||
|
init.display.flag.has_flag(INIT_DISPLAY_FLAG_BLACK_SPACE)) {
|
||||||
|
size_x = gps.dimx * dispx;
|
||||||
|
size_y = gps.dimy * dispy;
|
||||||
|
off_x = (screen->w - size_x) / 2;
|
||||||
|
off_y = (screen->h - size_y) / 2;
|
||||||
|
} else {
|
||||||
|
// If we're zooming (or just not using black space), we use the
|
||||||
|
// entire window.
|
||||||
|
size_x = screen->w;
|
||||||
|
size_y = screen->h;
|
||||||
|
off_x = off_y = 0;
|
||||||
|
}
|
||||||
|
glViewport(off_x, off_y, size_x, size_y);
|
||||||
|
glMatrixMode(GL_MODELVIEW);
|
||||||
|
glLoadIdentity();
|
||||||
|
glMatrixMode(GL_PROJECTION);
|
||||||
|
glLoadIdentity();
|
||||||
|
gluOrtho2D(0, gps.dimx, gps.dimy, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parameters: window size
|
||||||
|
void resize(int w, int h) {
|
||||||
|
// (Re)calculate grid-size
|
||||||
|
dispx = isFullscreen() ?
|
||||||
|
init.font.large_font_dispx :
|
||||||
|
init.font.small_font_dispx;
|
||||||
|
dispy = isFullscreen() ?
|
||||||
|
init.font.large_font_dispy :
|
||||||
|
init.font.small_font_dispy;
|
||||||
|
natural_w = MAX(w / dispx,1);
|
||||||
|
natural_h = MAX(h / dispy,1);
|
||||||
|
// Compute forced_steps so we satisfy our grid-size limits
|
||||||
|
compute_forced_zoom();
|
||||||
|
// Force a full display cycle
|
||||||
|
gps.force_full_display_count = 1;
|
||||||
|
df::global::enabler->flag |= ENABLERFLAG_RENDER;
|
||||||
|
// Reinitialize the video
|
||||||
|
uninit_opengl();
|
||||||
|
init_video(w, h);
|
||||||
|
init_opengl();
|
||||||
|
// Only reshape if we're free to pick grid size
|
||||||
|
if (df::global::enabler->overridden_grid_sizes.size() == 0)
|
||||||
|
reshape(compute_zoom());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parameters: grid size
|
||||||
|
void grid_resize(int w, int h) {
|
||||||
|
reshape(make_pair(w, h));
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
void set_fullscreen() {
|
||||||
|
if (isFullscreen()) {
|
||||||
|
init.display.desired_windowed_width = screen->w;
|
||||||
|
init.display.desired_windowed_height = screen->h;
|
||||||
|
resize(init.display.desired_fullscreen_width,
|
||||||
|
init.display.desired_fullscreen_height);
|
||||||
|
} else {
|
||||||
|
resize(init.display.desired_windowed_width, init.display.desired_windowed_height);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// Specialization for PARTIAL:0
|
||||||
|
class renderer_once : public renderer_opengl {
|
||||||
|
int tile_count;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
void update_tile(int x, int y) {
|
||||||
|
write_tile_vertexes(x, y, vertexes + tile_count * 6 * 2);
|
||||||
|
write_tile_arrays(x, y,
|
||||||
|
fg + tile_count * 6 * 4,
|
||||||
|
bg + tile_count * 6 * 4,
|
||||||
|
tex + tile_count * 6 * 2);
|
||||||
|
tile_count++;
|
||||||
|
}
|
||||||
|
|
||||||
|
void draw(int dummy) {
|
||||||
|
renderer_opengl::draw(tile_count*6);
|
||||||
|
tile_count = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
renderer_once() {
|
||||||
|
tile_count = 0;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// PARTIAL:N
|
||||||
|
class renderer_partial : public renderer_opengl {
|
||||||
|
int buffersz;
|
||||||
|
list<int> erasz; // Previous eras
|
||||||
|
int current_erasz; // And the current one
|
||||||
|
int sum_erasz;
|
||||||
|
int head, tail; // First unused tile, first used tile respectively
|
||||||
|
int redraw_count; // Number of eras to max out at
|
||||||
|
|
||||||
|
void update_tile(int x, int y) {
|
||||||
|
write_tile_vertexes(x, y, vertexes + head * 6 * 2);
|
||||||
|
write_tile_arrays(x, y,
|
||||||
|
fg + head * 6 * 4,
|
||||||
|
bg + head * 6 * 4,
|
||||||
|
tex + head * 6 * 2);
|
||||||
|
head = (head + 1) % buffersz;
|
||||||
|
current_erasz++; sum_erasz++;
|
||||||
|
if (head == tail) {
|
||||||
|
//gamelog << "Expanding partial-printing buffer" << endl;
|
||||||
|
// Buffer is full, expand it.
|
||||||
|
renderer_opengl::allocate(buffersz * 2);
|
||||||
|
// Move the tail to the end of the newly allocated space
|
||||||
|
tail += buffersz;
|
||||||
|
memmove(vertexes + tail * 6 * 2, vertexes + head * 6 * 2, sizeof(GLfloat) * 6 * 2 * (buffersz - head));
|
||||||
|
memmove(fg + tail * 6 * 4, fg + head * 6 * 4, sizeof(GLfloat) * 6 * 4 * (buffersz - head));
|
||||||
|
memmove(bg + tail * 6 * 4, fg + head * 6 * 4, sizeof(GLfloat) * 6 * 4 * (buffersz - head));
|
||||||
|
memmove(tex + tail * 6 * 2, fg + head * 6 * 2, sizeof(GLfloat) * 6 * 2 * (buffersz - head));
|
||||||
|
// And finish.
|
||||||
|
buffersz *= 2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void allocate(int tile_count) {
|
||||||
|
assert(false);
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void reshape_gl() {
|
||||||
|
// TODO: This function is duplicate code w/base class reshape_gl
|
||||||
|
// Setup invariant state
|
||||||
|
glEnableClientState(GL_COLOR_ARRAY);
|
||||||
|
/// Set up our coordinate system
|
||||||
|
if (forced_steps + zoom_steps == 0 &&
|
||||||
|
init.display.flag.has_flag(INIT_DISPLAY_FLAG_BLACK_SPACE)) {
|
||||||
|
size_x = gps.dimx * dispx;
|
||||||
|
size_y = gps.dimy * dispy;
|
||||||
|
off_x = (screen->w - size_x) / 2;
|
||||||
|
off_y = (screen->h - size_y) / 2;
|
||||||
|
} else {
|
||||||
|
// If we're zooming (or just not using black space), we use the
|
||||||
|
// entire window.
|
||||||
|
size_x = screen->w;
|
||||||
|
size_y = screen->h;
|
||||||
|
off_x = off_y = 0;
|
||||||
|
}
|
||||||
|
glViewport(off_x, off_y, size_x, size_y);
|
||||||
|
glMatrixMode(GL_MODELVIEW);
|
||||||
|
glLoadIdentity();
|
||||||
|
glMatrixMode(GL_PROJECTION);
|
||||||
|
glLoadIdentity();
|
||||||
|
gluOrtho2D(0, gps.dimx, gps.dimy, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void draw_arrays(GLfloat *vertexes, GLfloat *fg, GLfloat *bg, GLfloat *tex, int tile_count) {
|
||||||
|
// Set vertex pointer
|
||||||
|
glVertexPointer(2, GL_FLOAT, 0, vertexes);
|
||||||
|
// Render the background colors
|
||||||
|
glDisable(GL_TEXTURE_2D);
|
||||||
|
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||||
|
glDisable(GL_BLEND);
|
||||||
|
glDisable(GL_ALPHA_TEST);
|
||||||
|
glColorPointer(4, GL_FLOAT, 0, bg);
|
||||||
|
glDrawArrays(GL_TRIANGLES, 0, tile_count * 6);
|
||||||
|
// Render the foreground, colors and textures both
|
||||||
|
glEnable(GL_ALPHA_TEST);
|
||||||
|
glAlphaFunc(GL_NOTEQUAL, 0);
|
||||||
|
glEnable(GL_TEXTURE_2D);
|
||||||
|
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||||
|
glEnable(GL_BLEND);
|
||||||
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||||
|
glColorPointer(4, GL_FLOAT, 0, fg);
|
||||||
|
glTexCoordPointer(2, GL_FLOAT, 0, tex);
|
||||||
|
glDrawArrays(GL_TRIANGLES, 0, tile_count * 6);
|
||||||
|
}
|
||||||
|
|
||||||
|
void draw(int dummy) {
|
||||||
|
if (tail > head) {
|
||||||
|
// We're straddling the end of the array, so have to do this in two steps
|
||||||
|
draw_arrays(vertexes + tail * 6 * 2,
|
||||||
|
fg + tail * 6 * 4,
|
||||||
|
bg + tail * 6 * 4,
|
||||||
|
tex + tail * 6 * 2,
|
||||||
|
buffersz - tail);
|
||||||
|
draw_arrays(vertexes, fg, bg, tex, head-1);
|
||||||
|
} else {
|
||||||
|
draw_arrays(vertexes + tail * 6 * 2,
|
||||||
|
fg + tail * 6 * 4,
|
||||||
|
bg + tail * 6 * 4,
|
||||||
|
tex + tail * 6 * 2,
|
||||||
|
sum_erasz);
|
||||||
|
}
|
||||||
|
|
||||||
|
printGLError();
|
||||||
|
erasz.push_back(current_erasz); current_erasz = 0;
|
||||||
|
if (erasz.size() == redraw_count) {
|
||||||
|
// Right, time to retire the oldest era.
|
||||||
|
tail = (tail + erasz.front()) % buffersz;
|
||||||
|
sum_erasz -= erasz.front();
|
||||||
|
erasz.pop_front();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public:
|
||||||
|
renderer_partial() {
|
||||||
|
redraw_count = init.display.partial_print_count;
|
||||||
|
buffersz = 2048;
|
||||||
|
renderer_opengl::allocate(buffersz);
|
||||||
|
current_erasz = head = tail = sum_erasz = 0;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class renderer_accum_buffer : public renderer_once {
|
||||||
|
void draw(int vertex_count) {
|
||||||
|
// Copy the previous frame's buffer back in
|
||||||
|
glAccum(GL_RETURN, 1);
|
||||||
|
renderer_once::draw(vertex_count);
|
||||||
|
// Store the screen contents back to the buffer
|
||||||
|
glAccum(GL_LOAD, 1);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class renderer_framebuffer : public renderer_once {
|
||||||
|
GLuint framebuffer, fb_texture;
|
||||||
|
|
||||||
|
void init_opengl() {
|
||||||
|
glGenFramebuffersEXT(1, &framebuffer);
|
||||||
|
// Allocate FBO texture memory
|
||||||
|
glGenTextures(1, &fb_texture);
|
||||||
|
glBindTexture(GL_TEXTURE_2D, fb_texture);
|
||||||
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
|
||||||
|
screen->w, screen->h,
|
||||||
|
0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
||||||
|
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
|
||||||
|
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
|
||||||
|
|
||||||
|
// Bind texture to FBO
|
||||||
|
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, framebuffer);
|
||||||
|
glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
|
||||||
|
GL_TEXTURE_2D, fb_texture, 0);
|
||||||
|
renderer_once::init_opengl();
|
||||||
|
}
|
||||||
|
|
||||||
|
void uninit_opengl() {
|
||||||
|
renderer_once::uninit_opengl();
|
||||||
|
glDeleteTextures(1, &fb_texture);
|
||||||
|
glDeleteFramebuffersEXT(1, &framebuffer);
|
||||||
|
}
|
||||||
|
|
||||||
|
void draw(int vertex_count) {
|
||||||
|
// Bind the framebuffer
|
||||||
|
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, framebuffer);
|
||||||
|
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
|
||||||
|
// Draw
|
||||||
|
renderer_once::draw(vertex_count);
|
||||||
|
// Draw the framebuffer to screen
|
||||||
|
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
|
||||||
|
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, framebuffer);
|
||||||
|
glBlitFramebufferEXT(0,0, screen->w, screen->h,
|
||||||
|
0,0, screen->w, screen->h,
|
||||||
|
GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
||||||
|
printGLError();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class renderer_vbo : public renderer_opengl {
|
||||||
|
GLuint vbo; // Vertexes only
|
||||||
|
|
||||||
|
void init_opengl() {
|
||||||
|
renderer_opengl::init_opengl();
|
||||||
|
glGenBuffersARB(1, &vbo);
|
||||||
|
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
|
||||||
|
glBufferDataARB(GL_ARRAY_BUFFER_ARB, gps.dimx*gps.dimy*6*2*sizeof(GLfloat), vertexes, GL_STATIC_DRAW_ARB);
|
||||||
|
glVertexPointer(2, GL_FLOAT, 0, 0);
|
||||||
|
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void uninit_opengl() {
|
||||||
|
glDeleteBuffersARB(1, &vbo);
|
||||||
|
renderer_opengl::uninit_opengl();
|
||||||
|
}
|
||||||
|
};
|
||||||
Loading…
Reference in New Issue