m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
grafX2/src/tiles.c

509 lines
15 KiB
C
Raw Blame History

/* vim:expandtab:ts=2 sw=2:
*/
/* Grafx2 - The Ultimate 256-color bitmap paint program
Copyright 2011 Yves Rizoud
Copyright 2010-2011 Adrien Destugues
Grafx2 is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2
of the License.
Grafx2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Grafx2; if not, see <http://www.gnu.org/licenses/>
*/
#include "struct.h"
#include "global.h"
#include "graph.h"
#include "sdlscreen.h"
#include "engine.h"
#include "windows.h"
#include "input.h"
#include "misc.h"
#include "tiles.h"
enum TILE_FLIPPED
{
TILE_FLIPPED_NONE = 0,
TILE_FLIPPED_X = 1,
TILE_FLIPPED_Y = 2,
TILE_FLIPPED_XY = 3, // needs be TILE_FLIPPED_X|TILE_FLIPPED_Y
};
// globals
T_Tile * Main_tilemap;
short Main_tilemap_width;
short Main_tilemap_height;
T_Tile * Spare_tilemap;
short Spare_tilemap_width;
short Spare_tilemap_height;
//
/// Build the tile-area from the current picture
void build_tile_area()
{
word tileAreaWidth = Main_image_width / Snap_width + 1;
word tileAreaHeight = Main_image_height / Snap_height + 1;
int* tileArea = malloc(tileAreaWidth*tileAreaHeight*sizeof(int));
word tile_x, tile_y;
// For each tile, we have to crawl up to the top of the picture and
// find the first identical tile
for (tile_y = 0; tile_y < tileAreaWidth; tile_y++)
for(tile_x = 0; tile_x < tileAreaHeight; tile_x++)
{
// So, this is the "for each tile"
short ctx, cty;
// First we compare the tile with the others one in the same line at the left
for(ctx = tile_x - 1; ctx >= 0; ctx--)
if(compare_tiles(tile_x*Snap_width, tile_y*Snap_height, ctx*Snap_width, tile_y*Snap_height))
{
// We found a match !
tileArea[tile_y*tileAreaWidth+tile_x] = tile_y*tileAreaWidth+ctx;
goto found;
}
// Then we look at all the lines above
for(cty = tile_y - 1; cty >= 0; cty--)
for(ctx = tileAreaWidth - 1; ctx >= 0; ctx--)
if(compare_tiles(tile_x*Snap_width, tile_y*Snap_height, ctx*Snap_width, cty*Snap_height))
{
// We found a match !
tileArea[tile_y*tileAreaWidth+tile_x] = cty*tileAreaWidth+ctx;
goto found;
}
// Then we look at all the lines below
for(cty = tileAreaHeight - 1; cty >= tile_y; cty--)
for(ctx = tileAreaWidth - 1; ctx >= 0; ctx--)
if(compare_tiles(tile_x*Snap_width, tile_y*Snap_height, ctx*Snap_width, cty*Snap_height))
{
// We found a match !
tileArea[tile_y*tileAreaWidth+tile_x] = cty*tileAreaWidth+ctx;
goto found;
}
// Then we look at the tiles at the right of this one
// (including the tile itself, so we are sure we match something this time)
for(ctx = tileAreaHeight; ctx >= tile_x; ctx--)
if(compare_tiles(tile_x*Snap_width, tile_y*Snap_height, ctx*Snap_width, tile_y*Snap_height))
{
// We found a match !
tileArea[tile_y*tileAreaWidth+tile_x] = tile_y*tileAreaWidth+ctx;
}
found:
;
}
}
// Compare tiles
// The parameters are in pixel-space.
int compare_tiles(word x1, word y1, word x2, word y2)
{
word pixel_x, pixel_y;
byte c1, c2;
for (pixel_y = 0; pixel_y < Snap_width; pixel_y++)
for (pixel_x = 0; pixel_x < Snap_height; pixel_x++)
{
c1 = *(Main_screen + (y1+pixel_y) * Main_image_width + (x1+pixel_x));
c2 = *(Main_screen + (y2+pixel_y) * Main_image_width + (x2+pixel_x));
if (c1 != c2) return 0;
}
return 1;
}
/*
/// Copy a tile pixeldata to all the identical ones
// Call this after the end of an operation
void update_tile(word pixel_x, word pixel_y)
{
int tileOffset = (pixel_y/Snap_height)*tileAreaHeight + pixel_x/Snap_width;
int firstTileOffset = tileOffset + 1; // to make sure they are not equal
while(firstTileOffset != tileOffset)
{
tileOffset = tileArea[tileOffset];
//do the copy of a block starting at (pixel_x, pixel_y)
}
}
*/
/* Basic repeat-all
void Tilemap_draw(word x, word y, byte color)
{
int xx,yy;
for (yy=(y+Snap_height-Snap_offset_Y)%Snap_height+Snap_offset_Y;yy<Main_image_height;yy+=Snap_height)
for (xx=(x+Snap_width-Snap_offset_X)%Snap_width+Snap_offset_X;xx<Main_image_width;xx+=Snap_width)
Pixel_in_current_screen(xx,yy,color,yy>=Limit_top&&yy<=Limit_bottom&&xx>=Limit_left&&xx<=Limit_right);
Update_rect(0,0,0,0);
}
*/
void Tilemap_draw(word x, word y, byte color)
{
int tile, first_tile;
int rel_x, rel_y;
if (x < Snap_offset_X
|| y < Snap_offset_Y
|| x >= Snap_offset_X + Main_tilemap_width*Snap_width
|| y >= Snap_offset_Y + Main_tilemap_height*Snap_height)
return;
tile = first_tile = TILE_FOR_COORDS(x,y);
rel_x = (x - Snap_offset_X + Snap_width) % Snap_width;
rel_y = (y - Snap_offset_Y + Snap_height) % Snap_height;
do
{
int xx,yy;
switch(Main_tilemap[tile].Flipped ^ Main_tilemap[first_tile].Flipped)
{
case 0: // no
default:
xx = (tile % Main_tilemap_width)*Snap_width+Snap_offset_X + rel_x;
yy = (tile / Main_tilemap_width)*Snap_height+Snap_offset_Y + rel_y;
break;
case 1: // horizontal
xx = (tile % Main_tilemap_width)*Snap_width+Snap_offset_X + Snap_width-rel_x-1;
yy = (tile / Main_tilemap_width)*Snap_height+Snap_offset_Y + rel_y;
break;
case 2: // vertical
xx = (tile % Main_tilemap_width)*Snap_width+Snap_offset_X + rel_x;
yy = (tile / Main_tilemap_width)*Snap_height+Snap_offset_Y + Snap_height - rel_y - 1;
break;
case 3: // both
xx = (tile % Main_tilemap_width)*Snap_width+Snap_offset_X + Snap_width-rel_x-1;
yy = (tile / Main_tilemap_width)*Snap_height+Snap_offset_Y + Snap_height - rel_y - 1;
break;
}
if (yy>=Limit_top&&yy<=Limit_bottom&&xx>=Limit_left&&xx<=Limit_right)
Pixel_in_current_screen_with_preview(xx,yy,color);
else
Pixel_in_current_screen(xx,yy,color);
tile = Main_tilemap[tile].Next;
} while (tile != first_tile);
Update_rect(0,0,0,0);
}
///
int Tile_is_same(int t1, int t2)
{
byte *bmp1,*bmp2;
int y;
bmp1 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t1))*Main_image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t2))*Main_image_width+(TILE_X(t2));
for (y=0; y < Snap_height; y++)
{
if (memcmp(bmp1+y*Main_image_width, bmp2+y*Main_image_width, Snap_width))
return 0;
}
return 1;
}
///
int Tile_is_same_flipped_x(int t1, int t2)
{
byte *bmp1,*bmp2;
int y, x;
bmp1 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t1))*Main_image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t2))*Main_image_width+(TILE_X(t2)+Snap_width-1);
for (y=0; y < Snap_height; y++)
{
for (x=0; x < Snap_width; x++)
if (*(bmp1+y*Main_image_width+x) != *(bmp2+y*Main_image_width-x))
return 0;
}
return 1;
}
///
int Tile_is_same_flipped_y(int t1, int t2)
{
byte *bmp1,*bmp2;
int y;
bmp1 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t1))*Main_image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t2)+Snap_height-1)*Main_image_width+(TILE_X(t2));
for (y=0; y < Snap_height; y++)
{
if (memcmp(bmp1+y*Main_image_width, bmp2-y*Main_image_width, Snap_width))
return 0;
}
return 1;
}
///
int Tile_is_same_flipped_xy(int t1, int t2)
{
byte *bmp1,*bmp2;
int y, x;
bmp1 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t1))*Main_image_width+(TILE_X(t1));
bmp2 = Main_backups->Pages->Image[Main_current_layer].Pixels+(TILE_Y(t2)+Snap_height-1)*Main_image_width+(TILE_X(t2)+Snap_width-1);
for (y=0; y < Snap_height; y++)
{
for (x=0; x < Snap_width; x++)
if (*(bmp1+y*Main_image_width+x) != *(bmp2-y*Main_image_width-x))
return 0;
}
return 1;
}
/// Create or update a tilemap based on current screen (layer)'s pixels.
void Tilemap_update(void)
{
int width;
int height;
int tile;
int count=1;
T_Tile * tile_ptr;
int wait_window=0;
byte old_cursor=0;
if (!Main_tilemap_mode)
return;
width=(Main_image_width-Snap_offset_X)/Snap_width;
height=(Main_image_height-Snap_offset_Y)/Snap_height;
if (width<1 || height<1 || width*height>1000000l
|| (tile_ptr=(T_Tile *)malloc(width*height*sizeof(T_Tile))) == NULL)
{
// Cannot enable tilemap because either the image is too small
// for the grid settings (and I don't want to implement partial tiles)
// Or the number of tiles seems unreasonable (one million) : This can
// happen if you set grid 1x1 for example.
Disable_main_tilemap();
return;
}
if (Main_tilemap)
{
// Recycle existing tilemap
free(Main_tilemap);
Main_tilemap=NULL;
}
Main_tilemap=tile_ptr;
Main_tilemap_width=width;
Main_tilemap_height=height;
if (width*height > 1000 || Config.Tilemap_show_count)
{
wait_window=1;
old_cursor=Cursor_shape;
Open_window(180,36,"Creating tileset");
Print_in_window(26, 20, "Please wait...",MC_Black,MC_Light);
Cursor_shape=CURSOR_SHAPE_HOURGLASS;
Update_window_area(0,0,Window_width, Window_height);
Display_cursor();
Get_input(0);
}
// Initialize array with all tiles unique by default
for (tile=0; tile<width*height; tile++)
{
Main_tilemap[tile].Previous = tile;
Main_tilemap[tile].Next = tile;
Main_tilemap[tile].Flipped = 0;
}
// Now find similar tiles and link them in circular linked list
//It will be used to modify all tiles whenever you draw on one.
for (tile=1; tile<width*height; tile++)
{
int ref_tile;
// Try normal comparison
for (ref_tile=0; ref_tile<tile; ref_tile++)
{
if (Main_tilemap[ref_tile].Previous<=ref_tile && Tile_is_same(ref_tile, tile))
{
break; // stop loop on ref_tile
}
}
if (ref_tile<tile)
{
// New occurence of a known tile
// Insert at the end. classic doubly-linked-list.
int last_tile=Main_tilemap[ref_tile].Previous;
Main_tilemap[tile].Previous=last_tile;
Main_tilemap[tile].Next=ref_tile;
Main_tilemap[tile].Flipped=Main_tilemap[ref_tile].Flipped;
Main_tilemap[ref_tile].Previous=tile;
Main_tilemap[last_tile].Next=tile;
continue; // next tile
}
// Try flipped-y comparison
if (Config.Tilemap_allow_flipped_y)
{
for (ref_tile=0; ref_tile<tile; ref_tile++)
{
if (Main_tilemap[ref_tile].Previous<=ref_tile && Tile_is_same_flipped_y(ref_tile, tile))
{
break; // stop loop on ref_tile
}
}
if (ref_tile<tile)
{
// New occurence of a known tile
// Insert at the end. classic doubly-linked-list.
int last_tile=Main_tilemap[ref_tile].Previous;
Main_tilemap[tile].Previous=last_tile;
Main_tilemap[tile].Next=ref_tile;
Main_tilemap[tile].Flipped=Main_tilemap[ref_tile].Flipped ^ TILE_FLIPPED_Y;
Main_tilemap[ref_tile].Previous=tile;
Main_tilemap[last_tile].Next=tile;
continue; // next tile
}
}
// Try flipped-x comparison
if (Config.Tilemap_allow_flipped_x)
{
for (ref_tile=0; ref_tile<tile; ref_tile++)
{
if (Main_tilemap[ref_tile].Previous<=ref_tile && Tile_is_same_flipped_x(ref_tile, tile))
{
break; // stop loop on ref_tile
}
}
if (ref_tile<tile)
{
// New occurence of a known tile
// Insert at the end. classic doubly-linked-list.
int last_tile=Main_tilemap[ref_tile].Previous;
Main_tilemap[tile].Previous=last_tile;
Main_tilemap[tile].Next=ref_tile;
Main_tilemap[tile].Flipped=Main_tilemap[ref_tile].Flipped ^ TILE_FLIPPED_X;
Main_tilemap[ref_tile].Previous=tile;
Main_tilemap[last_tile].Next=tile;
continue; // next tile
}
}
// Try flipped-xy comparison
if (Config.Tilemap_allow_flipped_x && Config.Tilemap_allow_flipped_y)
{
for (ref_tile=0; ref_tile<tile; ref_tile++)
{
if (Main_tilemap[ref_tile].Previous<=ref_tile && Tile_is_same_flipped_xy(ref_tile, tile))
{
break; // stop loop on ref_tile
}
}
if (ref_tile<tile)
{
// New occurence of a known tile
// Insert at the end. classic doubly-linked-list.
int last_tile=Main_tilemap[ref_tile].Previous;
Main_tilemap[tile].Previous=last_tile;
Main_tilemap[tile].Next=ref_tile;
Main_tilemap[tile].Flipped=Main_tilemap[ref_tile].Flipped ^ TILE_FLIPPED_XY;
Main_tilemap[ref_tile].Previous=tile;
Main_tilemap[last_tile].Next=tile;
continue; // next tile
}
}
// This tile is really unique.
// Nothing to do at this time: the initialization
// has already set the right data for Main_tilemap[tile].
count++;
}
if (wait_window)
{
char str[8];
Uint32 end;
if (Config.Tilemap_show_count)
{
Num2str(count,str,7);
Hide_cursor();
Print_in_window(6, 20, "Unique tiles: ",MC_Black,MC_Light);
Print_in_window(6+8*14,20,str,MC_Black,MC_Light);
Display_cursor();
// Wait a moment to display count
end = SDL_GetTicks()+750;
do
{
Get_input(20);
} while (SDL_GetTicks()<end);
}
Close_window();
Cursor_shape=old_cursor;
Display_cursor();
}
}
void Swap_tilemap(void)
{
SWAP_BYTES(Main_tilemap_mode, Spare_tilemap_mode)
{
T_Tile * a;
a=Main_tilemap;
Main_tilemap=Spare_tilemap;
Spare_tilemap=a;
}
SWAP_SHORTS(Main_tilemap_width, Spare_tilemap_width)
SWAP_SHORTS(Main_tilemap_height, Spare_tilemap_height)
}
void Disable_main_tilemap(void)
{
if (Main_tilemap)
{
// Recycle existing tilemap
free(Main_tilemap);
Main_tilemap=NULL;
}
Main_tilemap_width=0;
Main_tilemap_height=0;
Main_tilemap_mode=0;
}
void Disable_spare_tilemap(void)
{
if (Spare_tilemap)
{
// Recycle existing tilemap
free(Spare_tilemap);
Spare_tilemap=NULL;
}
Spare_tilemap_width=0;
Spare_tilemap_height=0;
Spare_tilemap_mode=0;
}
Reference in New Issue View Git Blame Copy Permalink