MetzNet
/
dfhack
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rendermax: removed all the opengl and sdl stuff. Now it work with magic alone.

develop
Warmist 2013-06-22 03:45:42 +03:00
parent dec0b202ee
commit 55d845992c
2 changed files with 161 additions and 641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
plugins/rendermax/CMakeLists.txt
Unescape Escape View File

@ -1,7 +1,5 @@
PROJECT (rendermax)
Find_Package(SDL REQUIRED)
find_package(OpenGL REQUIRED)
find_package(GLUT REQUIRED)
# A list of source files
SET(PROJECT_SRCS
rendermax.cpp
@ -14,23 +12,19 @@ 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)
)

792
plugins/rendermax/renderer_opengl.hpp
Unescape Escape View File

@ -6,653 +6,179 @@
#include "df/enabler.h"
#include "df/zoom_commands.h"
#include "df/texture_handler.h"
#include "df/graphic.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()
struct old_opengl:public renderer
{
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;
}
void* sdlSurface;
int32_t dispx,dispy;
float *vertexes, *fg, *bg, *tex;
int32_t zoom_steps,forced_steps,natural_w,natural_h;
int32_t off_x,off_y,size_x,size_y;
};
// 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));
struct renderer_wrap : public renderer {
private:
void set_to_null() {
screen = NULL;
screentexpos = NULL;
screentexpos_addcolor = NULL;
screentexpos_grayscale = NULL;
screentexpos_cf = NULL;
screentexpos_cbr = NULL;
screen_old = NULL;
screentexpos_old = NULL;
screentexpos_addcolor_old = NULL;
screentexpos_grayscale_old = NULL;
screentexpos_cf_old = NULL;
screentexpos_cbr_old = NULL;
}
void copy_from_inner() {
screen = parent->screen;
screentexpos = parent->screentexpos;
screentexpos_addcolor = parent->screentexpos_addcolor;
screentexpos_grayscale = parent->screentexpos_grayscale;
screentexpos_cf = parent->screentexpos_cf;
screentexpos_cbr = parent->screentexpos_cbr;
screen_old = parent->screen_old;
screentexpos_old = parent->screentexpos_old;
screentexpos_addcolor_old = parent->screentexpos_addcolor_old;
screentexpos_grayscale_old = parent->screentexpos_grayscale_old;
screentexpos_cf_old = parent->screentexpos_cf_old;
screentexpos_cbr_old = parent->screentexpos_cbr_old;
}
void copy_to_inner() {
parent->screen = screen;
parent->screentexpos = screentexpos;
parent->screentexpos_addcolor = screentexpos_addcolor;
parent->screentexpos_grayscale = screentexpos_grayscale;
parent->screentexpos_cf = screentexpos_cf;
parent->screentexpos_cbr = screentexpos_cbr;
parent->screen_old = screen_old;
parent->screentexpos_old = screentexpos_old;
parent->screentexpos_addcolor_old = screentexpos_addcolor_old;
parent->screentexpos_grayscale_old = screentexpos_grayscale_old;
parent->screentexpos_cf_old = screentexpos_cf_old;
parent->screentexpos_cbr_old = screentexpos_cbr_old;
}
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);
renderer_wrap(renderer* parent):parent(parent)
{
copy_from_inner();
}
}
};
virtual void update_tile(int32_t x, int32_t y) {
// Specialization for PARTIAL:0
class renderer_once : public renderer_opengl {
int tile_count;
copy_to_inner();
parent->update_tile(x,y);
};
virtual void update_all() {
copy_to_inner();
parent->update_all();
};
virtual void render() {
copy_to_inner();
parent->render();
};
virtual void set_fullscreen() {
copy_to_inner();
parent->set_fullscreen();
};
virtual void zoom(df::zoom_commands z) {
copy_to_inner();
parent->zoom(z);
};
virtual void resize(int32_t w, int32_t h) {
copy_to_inner();
parent->resize(w,h);
copy_from_inner();
};
virtual void grid_resize(int32_t w, int32_t h) {
copy_to_inner();
parent->grid_resize(w,h);
copy_from_inner();
};
virtual ~renderer_wrap() {
df::global::enabler->renderer=parent;
};
virtual bool get_mouse_coords(int32_t* x, int32_t* y) {
return parent->get_mouse_coords(x,y);
};
virtual bool uses_opengl() {
return parent->uses_opengl();
};
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;
}
renderer* parent;
};
// 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();
struct renderer_trippy : public renderer_wrap {
private:
float rFloat()
{
return rand()/(float)RAND_MAX;
}
void colorizeTile(int x,int y)
{
const int tile = x*(df::global::gps->dimy) + y;
old_opengl* p=reinterpret_cast<old_opengl*>(parent);
float *fg = p->fg + tile * 4 * 6;
float *bg = p->bg + tile * 4 * 6;
float *tex = p->tex + tile * 2 * 6;
const float val=1/2.0;
float r=rFloat()*val - val/2;
float g=rFloat()*val - val/2;
float b=rFloat()*val - val/2;
float backr=rFloat()*val - val/2;
float backg=rFloat()*val - val/2;
float backb=rFloat()*val - val/2;
for (int i = 0; i < 6; i++) {
*(fg++) += r;
*(fg++) += g;
*(fg++) += b;
*(fg++) = 1;
*(bg++) += backr;
*(bg++) += backg;
*(bg++) += backb;
*(bg++) = 1;
}
}
}
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);
}
renderer_trippy(renderer* parent):renderer_wrap(parent)
{
}
virtual void update_tile(int32_t x, int32_t y) {
renderer_wrap::update_tile(x,y);
colorizeTile(x,y);
};
virtual void update_all() {
renderer_wrap::update_all();
for (int x = 0; x < df::global::gps->dimx; x++)
for (int y = 0; y < df::global::gps->dimy; y++)
colorizeTile(x,y);
};
};
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);
struct renderer_test : public renderer_wrap {
private:
// 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();
}
};
public:
renderer_test(renderer* parent):renderer_wrap(parent)
{
}
virtual void update_tile(int32_t x, int32_t y) {
renderer_wrap::update_tile(x,y);
//some sort of mutex or sth?
//and then map read
};
virtual void update_all() {
renderer_wrap::update_all();
//some sort of mutex or sth?
//and then map read
//same stuff for all of them i guess...
};
};