dfhack/plugins/rendermax/renderer_opengl.hpp

//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"
#include "df/graphic.h"

using df::renderer;
using df::init;
using df::enabler;

struct old_opengl:public renderer
{
    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;
};
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;
    }
public:
    renderer_wrap(renderer* parent):parent(parent)
    {
        copy_from_inner();
    }
    virtual void update_tile(int32_t x, int32_t y) { 

        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:
    renderer* parent;
};
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_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);
    };
};
struct renderer_test : public renderer_wrap {
private:
    
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...
    };
};