#include "Overlay.h"

#include "TrackingModes.h"

#include "Hooks.h"

#include "GUI.h"

#include "modules/DFSDL.h"

#include "df/init.h"

#include "df/viewscreen_dwarfmodest.h"

//#include "df/viewscreen_dungeonmodest.h"

#include "df/adventurest.h"

using namespace std;

using namespace DFHack;

using namespace df::enums;

void Overlay::ReadTileLocations()

{

//fontx = df::global::init->font.small_font_dispx;

//fonty = df::global::init->font.small_font_dispy;

//actualWindowSize(width, height);

//DFHack::DFSDL_Surface * dfsurf = (DFHack::DFSDL_Surface *) SDL_GetVideoSurface();

//offsetx = fontx+((dfsurf->w) % fontx)/2;

//offsety = fontx+((dfsurf->h) % fonty)/2;

//if (!df::global::gamemode || *df::global::gamemode == game_mode::ADVENTURE)

//{

// //Adventure mode doesn't have a single-tile border around it.

// offsetx = offsetx - fontx;

// offsety = offsety - fonty;

//}

//ssState.ScreenW = fontx*width;

//ssState.ScreenH = fonty*height;

}

void Overlay::CheckViewscreen()

{

df::viewscreen * vs = Gui::getCurViewscreen();

virtual_identity * id = virtual_identity::get(vs);

if (id == &df::viewscreen_dwarfmodest::_identity)

{

good_viewscreen = true;

}

/* FIXME when adventure is back.

else if (id == &df::viewscreen_dungeonmodest::_identity)

{

if (!df::global::adventure)

good_viewscreen = true;

else if (df::global::adventure->menu == df::ui_advmode_menu::Default)

good_viewscreen = true;

else if (df::global::adventure->menu == df::ui_advmode_menu::ConversationAddress)

good_viewscreen = true;

else

good_viewscreen = false;

}

*/

else

{

good_viewscreen = false;

}

}

bool Overlay::PaintingOverTileAt(int32_t x, int32_t y)

{

if (!df::global::gamemode || *df::global::gamemode == game_mode::ADVENTURE)

return x >= 0 && x <= width && y >= 0 && y <= height;

else

return x > 0 && x <= width && y > 0 && y <= height;

}

void Overlay::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 Overlay::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 Overlay::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;

*/

}

Overlay::Overlay(renderer* parent) : parent(parent)

{

{

CoreSuspender suspend;

//parent->zoom(df::zoom_commands::zoom_reset);

good_viewscreen = false;

ReadTileLocations();

copy_from_inner();

}

front_mutex = al_create_mutex();

int32_t flags = al_get_new_bitmap_flags();

if(al_get_current_display() != NULL){

al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST);

}

front = al_create_bitmap(0,0);

if(al_get_current_display() != NULL){

al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display())));

}

back = al_create_bitmap(0,0);

al_set_new_bitmap_flags(flags);

Flip();

};

Overlay::~Overlay()

{

{

CoreSuspender suspend;

df::global::enabler->renderer = parent;

}

al_destroy_mutex(front_mutex);

al_destroy_bitmap(front);

al_destroy_bitmap(back);

front = back = NULL;

if(al_get_current_display() == NULL){

al_set_target_bitmap(NULL);

} else {

al_set_target_bitmap(al_get_backbuffer(al_get_current_display()));

}

}

void Overlay::Flip()

{

//do the starting timer stuff

clock_t starttime = clock();

al_lock_mutex(front_mutex);

{

al_unlock_bitmap(front);

if(al_get_bitmap_width(front) != ssState.ScreenW

|| al_get_bitmap_height(front) != ssState.ScreenH){

al_destroy_bitmap(front);

int32_t flags = al_get_new_bitmap_flags();

if(al_get_current_display() != NULL){

al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST);

}

front = al_create_bitmap(ssState.ScreenW, ssState.ScreenH);

al_set_new_bitmap_flags(flags);

}

al_set_target_bitmap(front);

al_draw_bitmap(back, 0, 0, 0);

front_data = al_lock_bitmap(front,

al_get_bitmap_format(front), ALLEGRO_LOCK_READONLY);

}

front_updated = true;

al_unlock_mutex(front_mutex);

if(al_get_bitmap_width(back) != ssState.ScreenW

|| al_get_bitmap_height(back) != ssState.ScreenH){

al_destroy_bitmap(back);

int32_t flags = al_get_new_bitmap_flags();

if(al_get_current_display() != NULL){

al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display())));

}

back = al_create_bitmap(ssState.ScreenW, ssState.ScreenH);

al_set_new_bitmap_flags(flags);

}

al_set_target_bitmap(back);

//do the ending timer stuff

clock_t donetime = clock();

ssTimers.overlay_time = (donetime - starttime)*0.1 + ssTimers.overlay_time*0.9;

}

bool Overlay::GoodViewscreen()

{

return good_viewscreen;

}

void Overlay::update_tile(int32_t x, int32_t y)

{

//don't update tiles we are painting overtop of

if(!PaintingOverTileAt(x,y)){

copy_to_inner();

parent->update_tile(x,y);

}

}

void Overlay::update_all()

{

copy_to_inner();

parent->update_all();

front_updated = true;

}

void Overlay::render()

{

copy_to_inner();

al_lock_mutex(front_mutex);

CheckViewscreen();

ReadTileLocations();

if(good_viewscreen){

if(front_data != NULL && front_updated){

//allegro sometimes gives a negative pitch, which SDL doesn't understand, so take care of that case

int neg = 1;

int dataoffset = 0;

if(front_data->pitch < 0){

neg = -1;

dataoffset = (al_get_bitmap_height(front) - 1)*front_data->pitch;

}

//get the SDL surface information so we can do a blit

DFHack::DFSDL_Surface * dfsurf = (DFHack::DFSDL_Surface *) DFHack::DFSDL::DFSDL_GetVideoSurface();

DFHack::DFSDL_Surface * sssurf = (DFHack::DFSDL_Surface *) DFHack::DFSDL::DFSDL_CreateRGBSurfaceFrom( ((char*) front_data->data) + dataoffset,

al_get_bitmap_width(front), al_get_bitmap_height(front), 8*front_data->pixel_size, neg*front_data->pitch, 0, 0, 0, 0);

DFSDL_Rect src;

src.x = 0;

src.y = 0;

src.w = ssState.ScreenW;

src.h = ssState.ScreenH;

DFSDL_Rect pos;

pos.x = offsetx;

pos.y = offsety;

pos.w = 0;

pos.h = 0;

//do the blit

DFHack::DFSDL::DFSDL_UpperBlit(sssurf, &src, dfsurf, &pos);

DFHack::DFSDL::DFSDL_FreeSurface(sssurf);

}

front_updated = false;

} else {

width = 0;

height = 0;

}

al_unlock_mutex(front_mutex);

parent->render();

}

void Overlay::set_fullscreen()

{

copy_to_inner();

parent->set_fullscreen();

copy_from_inner();

}

void Overlay::zoom(df::zoom_commands z)

{

copy_to_inner();

parent->zoom(df::zoom_commands::zoom_reset);

//parent->zoom(z);

copy_from_inner();

//switch (z) {

//case df::zoom_commands::zoom_fullscreen:

// //???

// break;

//case df::zoom_commands::zoom_in:

// ssConfig.zoom++;

// ssConfig.scale = pow(2.0f, ssConfig.zoom);

// break;

//case df::zoom_commands::zoom_out:

// ssConfig.zoom--;

// ssConfig.scale = pow(2.0f, ssConfig.zoom);

// break;

//case df::zoom_commands::zoom_reset:

// ssConfig.zoom = 5;

// ssConfig.scale = pow(2.0f, ssConfig.zoom);

// break;

//case df::zoom_commands::zoom_resetgrid:

// //???

// break;

//}

}

void Overlay::resize(int32_t w, int32_t h)

{

copy_to_inner();

parent->resize(w,h);

copy_from_inner();

}

void Overlay::grid_resize(int32_t w, int32_t h)

{

copy_to_inner();

parent->grid_resize(w,h);

copy_from_inner();

}

bool Overlay::get_mouse_coords(int32_t* x, int32_t* y)

{

/*FIXME: Find a new replacement for the overlay mode.

//PrintMessage("in:(%i,%i)\n",*x,*y);

bool ret = parent->get_mouse_coords(x,y);

//PrintMessage("out:(%i,%i)\n",*x,*y);

//if we are painting over the tile, then we need to reroute through stonesense

if(ret && PaintingOverTileAt(*x,*y)){

int xpx, ypx, xpos, ypos, zpos;

SDL_GetMouseState(&xpx, &ypx);

xpx = xpx - offsetx;

ypx = ypx - offsety;

//first figure out which tile in the segment it came from

ScreenToPoint(xpx,ypx,xpos,ypos,zpos);

//then remove the segment rotation

correctForRotation(

xpos, ypos,

(4 - ssState.Rotation) % 4,

ssState.Size.x, ssState.Size.y);

//add on the segment offset

xpos = xpos + ssState.Position.x;

ypos = ypos + ssState.Position.y;

//zpos = zpos + ssState.Position.z - 1;

//remove the offset of the df window

int dfviewx, dfviewy, dfviewz;

Gui::getViewCoords(dfviewx, dfviewy, dfviewz);

xpos = xpos - dfviewx + 1;

ypos = ypos - dfviewy + 1;

//zpos = zpos - dfviewz;

if (!df::global::gamemode || *df::global::gamemode == game_mode::ADVENTURE)

{

//Adventure mode doesn't have a single-tile border around it.

xpos = xpos - 1;

ypos = ypos - 1;

}

//check to see if this new loaction is within the area we are painting over

//since we don't want to accidentally click somewhere in the interface

if(PaintingOverTileAt(xpos,ypos)) {

*x = xpos;

*y = ypos;

return true;

} else {

*x = -1;

*y = -1;

return false;

}

}

return ret;

*/

return false;

}

bool Overlay::uses_opengl()

{

return parent->uses_opengl();

}