/**
* im_draw_mask:
* @image: image to draw on
* @x: draw mask here
* @y: draw mask here
* @ink: value to draw
* @mask_im: mask of 0/255 values showing where to plot
*
* Draw a mask on the image. @mask_im is a monochrome 8-bit image with 0/255
* for transparent or @ink coloured points. Intermediate values blend the ink
* with the pixel. Use with im_text() to draw text on an image.
*
* @ink is an array of bytes
* containing a valid pixel for the image's format.
* It must have at least IM_IMAGE_SIZEOF_PEL( @image ) bytes.
*
* See also: im_draw_circle(), im_text(), im_draw_line_user().
*
* Returns: 0 on success, or -1 on error.
*/
int
im_draw_mask( VipsImage *image, VipsImage *mask_im, int x, int y, PEL *ink )
{
Mask *mask;
if( !(mask = mask_new( image, x, y, ink, mask_im )) )
return( -1 );
/* Any points to plot?
*/
if( im_rect_isempty( &mask->image_clip ) ) {
mask_free( mask );
return( 0 );
}
/* Loop through image plotting where required.
*/
switch( image->Coding ) {
case IM_CODING_LABQ:
if( mask_draw_labq( mask ) ) {
mask_free( mask );
return( 0 );
}
break;
case IM_CODING_NONE:
if( mask_draw( mask ) ) {
mask_free( mask );
return( 0 );
}
break;
default:
g_assert( 0 );
}
mask_free( mask );
return( 0 );
}
static Mask *
mask_new( VipsImage *im, int x, int y, PEL *ink, VipsImage *mask_im )
{
Mask *mask;
Rect area, image;
if( im_check_coding_noneorlabq( "im_draw_mask", im ) ||
im_incheck( mask_im ) ||
im_check_mono( "im_draw_mask", mask_im ) ||
im_check_uncoded( "im_draw_mask", mask_im ) ||
im_check_format( "im_draw_mask", mask_im, IM_BANDFMT_UCHAR ) ||
!(mask = IM_NEW( NULL, Mask )) )
return( NULL );
if( !im__draw_init( DRAW( mask ), im, ink ) ) {
mask_free( mask );
return( NULL );
}
mask->x = x;
mask->y = y;
mask->mask_im = mask_im;
/* Find the area we draw on the image.
*/
area.left = x;
area.top = y;
area.width = mask_im->Xsize;
area.height = mask_im->Ysize;
image.left = 0;
image.top = 0;
image.width = im->Xsize;
image.height = im->Ysize;
im_rect_intersectrect( &area, &image, &mask->image_clip );
/* And the area of the mask image we use.
*/
mask->mask_clip = mask->image_clip;
mask->mask_clip.left -= x;
mask->mask_clip.top -= y;
return( mask );
}
/**
* [working thread]
*/
virtual void onJob()
{
UndoTransaction undoTransaction(m_document, "Rotate Canvas");
// get all sprite cels
CelList cels;
m_sprite->getCels(cels);
// for each cel...
for (CelIterator it = cels.begin(); it != cels.end(); ++it) {
Cel* cel = *it;
Image* image = m_sprite->getStock()->getImage(cel->getImage());
// change it location
switch (m_angle) {
case 180:
undoTransaction.setCelPosition(cel,
m_sprite->getWidth() - cel->getX() - image->w,
m_sprite->getHeight() - cel->getY() - image->h);
break;
case 90:
undoTransaction.setCelPosition(cel, m_sprite->getHeight() - cel->getY() - image->h, cel->getX());
break;
case -90:
undoTransaction.setCelPosition(cel, cel->getY(), m_sprite->getWidth() - cel->getX() - image->w);
break;
}
}
// for each stock's image
for (int i=0; i<m_sprite->getStock()->size(); ++i) {
Image* image = m_sprite->getStock()->getImage(i);
if (!image)
continue;
// rotate the image
Image* new_image = image_new(image->imgtype,
m_angle == 180 ? image->w: image->h,
m_angle == 180 ? image->h: image->w);
image_rotate(image, new_image, m_angle);
undoTransaction.replaceStockImage(i, new_image);
jobProgress((float)i / m_sprite->getStock()->size());
// cancel all the operation?
if (isCanceled())
return; // UndoTransaction destructor will undo all operations
}
// rotate mask
if (m_document->isMaskVisible()) {
Mask* origMask = m_document->getMask();
Mask* new_mask = mask_new();
int x = 0, y = 0;
switch (m_angle) {
case 180:
x = m_sprite->getWidth() - origMask->x - origMask->w;
y = m_sprite->getHeight() - origMask->y - origMask->h;
break;
case 90:
x = m_sprite->getHeight() - origMask->y - origMask->h;
y = origMask->x;
break;
case -90:
x = origMask->y;
y = m_sprite->getWidth() - origMask->x - origMask->w;
break;
}
// create the new rotated mask
mask_replace(new_mask, x, y,
m_angle == 180 ? origMask->w: origMask->h,
m_angle == 180 ? origMask->h: origMask->w);
image_rotate(origMask->bitmap, new_mask->bitmap, m_angle);
// copy new mask
undoTransaction.copyToCurrentMask(new_mask);
mask_free(new_mask);
// regenerate mask
m_document->generateMaskBoundaries();
}
// change the sprite's size
if (m_angle != 180)
undoTransaction.setSpriteSize(m_sprite->getHeight(), m_sprite->getWidth());
// commit changes
undoTransaction.commit();
}
void update_grav(void)
{
int x, y, i, j, changed = 0;
float val, distance;
th_gravchanged = 0;
#ifndef GRAV_DIFF
//Find any changed cells
for (i=0; i<YRES/CELL; i++)
{
if(changed)
break;
for (j=0; j<XRES/CELL; j++)
{
if(th_ogravmap[i*(XRES/CELL)+j]!=th_gravmap[i*(XRES/CELL)+j]){
changed = 1;
break;
}
}
}
if(!changed)
goto fin;
memset(th_gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
#endif
th_gravchanged = 1;
for (i = 0; i < YRES / CELL; i++) {
for (j = 0; j < XRES / CELL; j++) {
#ifdef GRAV_DIFF
if (th_ogravmap[i*(XRES/CELL)+j] != th_gravmap[i*(XRES/CELL)+j])
{
#else
if (th_gravmap[i*(XRES/CELL)+j] > 0.0001f || th_gravmap[i*(XRES/CELL)+j]<-0.0001f) //Only calculate with populated or changed cells.
{
#endif
for (y = 0; y < YRES / CELL; y++) {
for (x = 0; x < XRES / CELL; x++) {
if (x == j && y == i)//Ensure it doesn't calculate with itself
continue;
distance = sqrt(pow(j - x, 2) + pow(i - y, 2));
#ifdef GRAV_DIFF
val = th_gravmap[i*(XRES/CELL)+j] - th_ogravmap[i*(XRES/CELL)+j];
#else
val = th_gravmap[i*(XRES/CELL)+j];
#endif
th_gravx[y*(XRES/CELL)+x] += M_GRAV * val * (j - x) / pow(distance, 3);
th_gravy[y*(XRES/CELL)+x] += M_GRAV * val * (i - y) / pow(distance, 3);
th_gravp[y*(XRES/CELL)+x] += M_GRAV * val / pow(distance, 2);
}
}
}
}
}
fin:
memcpy(th_ogravmap, th_gravmap, (XRES/CELL)*(YRES/CELL)*sizeof(float));
}
#endif
void grav_mask_r(int x, int y, char checkmap[YRES/CELL][XRES/CELL], char shape[YRES/CELL][XRES/CELL], char *shapeout)
{
if(x < 0 || x >= XRES/CELL || y < 0 || y >= YRES/CELL)
return;
if(x == 0 || y ==0 || y == (YRES/CELL)-1 || x == (XRES/CELL)-1)
*shapeout = 1;
checkmap[y][x] = 1;
shape[y][x] = 1;
if(x-1 >= 0 && !checkmap[y][x-1] && globalSim->walls.type(SimPosCell(x-1,y))!=WL_GRAV)
grav_mask_r(x-1, y, checkmap, shape, shapeout);
if(y-1 >= 0 && !checkmap[y-1][x] && globalSim->walls.type(SimPosCell(x,y-1))!=WL_GRAV)
grav_mask_r(x, y-1, checkmap, shape, shapeout);
if(x+1 < XRES/CELL && !checkmap[y][x+1] && globalSim->walls.type(SimPosCell(x+1,y))!=WL_GRAV)
grav_mask_r(x+1, y, checkmap, shape, shapeout);
if(y+1 < YRES/CELL && !checkmap[y+1][x] && globalSim->walls.type(SimPosCell(x,y+1))!=WL_GRAV)
grav_mask_r(x, y+1, checkmap, shape, shapeout);
return;
}
struct mask_el;
typedef struct mask_el mask_el;
struct mask_el {
char *shape;
char shapeout;
mask_el *next;
};
void mask_free(mask_el *c_mask_el){
if(c_mask_el==NULL)
return;
if(c_mask_el->next!=NULL)
mask_free(c_mask_el->next);
free(c_mask_el->shape);
free(c_mask_el);
}
void gravity_mask()
{
char checkmap[YRES/CELL][XRES/CELL];
int x = 0, y = 0;
unsigned maskvalue;
mask_el *t_mask_el = NULL;
mask_el *c_mask_el = NULL;
if(!gravmask)
return;
memset(checkmap, 0, sizeof(checkmap));
for(x = 0; x < XRES/CELL; x++)
{
for(y = 0; y < YRES/CELL; y++)
{
if(globalSim->walls.type(SimPosCell(x,y))!=WL_GRAV && checkmap[y][x] == 0)
{
//Create a new shape
if(t_mask_el==NULL){
t_mask_el = (mask_el*)malloc(sizeof(mask_el));
t_mask_el->shape = (char*)malloc((XRES/CELL)*(YRES/CELL));
memset(t_mask_el->shape, 0, (XRES/CELL)*(YRES/CELL));
t_mask_el->shapeout = 0;
t_mask_el->next = NULL;
c_mask_el = t_mask_el;
} else {
c_mask_el->next = (mask_el*)malloc(sizeof(mask_el));
c_mask_el = c_mask_el->next;
c_mask_el->shape = (char*)malloc((XRES/CELL)*(YRES/CELL));
memset(c_mask_el->shape, 0, (XRES/CELL)*(YRES/CELL));
c_mask_el->shapeout = 0;
c_mask_el->next = NULL;
}
//Fill the shape
grav_mask_r(x, y, checkmap, (char(*)[XRES/CELL])c_mask_el->shape, &c_mask_el->shapeout);
}
}
}
c_mask_el = t_mask_el;
memset(gravmask, 0, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
while(c_mask_el!=NULL)
{
char *cshape = c_mask_el->shape;
for(x = 0; x < XRES/CELL; x++)
{
for(y = 0; y < YRES/CELL; y++)
{
if(cshape[y*(XRES/CELL)+x]){
if(c_mask_el->shapeout)
maskvalue = 0xFFFFFFFF;
else
maskvalue = 0x00000000;
gravmask[y*(XRES/CELL)+x] = maskvalue;
}
}
}
c_mask_el = c_mask_el->next;
}
mask_free(t_mask_el);
}
void Gravity::update_grav(void)
{
int x, y, i, j, changed = 0;
float val, distance;
th_gravchanged = 0;
#ifndef GRAV_DIFF
//Find any changed cells
for (i=0; i<YRES/CELL; i++)
{
if(changed)
break;
for (j=0; j<XRES/CELL; j++)
{
if(th_ogravmap[i*(XRES/CELL)+j]!=th_gravmap[i*(XRES/CELL)+j]){
changed = 1;
break;
}
}
}
if(!changed)
goto fin;
memset(th_gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
#endif
th_gravchanged = 1;
membwand(th_gravmap, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
for (i = 0; i < YRES / CELL; i++) {
for (j = 0; j < XRES / CELL; j++) {
#ifdef GRAV_DIFF
if (th_ogravmap[i*(XRES/CELL)+j] != th_gravmap[i*(XRES/CELL)+j])
{
#else
if (th_gravmap[i*(XRES/CELL)+j] > 0.0001f || th_gravmap[i*(XRES/CELL)+j]<-0.0001f) //Only calculate with populated or changed cells.
{
#endif
for (y = 0; y < YRES / CELL; y++) {
for (x = 0; x < XRES / CELL; x++) {
if (x == j && y == i)//Ensure it doesn't calculate with itself
continue;
distance = sqrt(pow(j - x, 2.0f) + pow(i - y, 2.0f));
#ifdef GRAV_DIFF
val = th_gravmap[i*(XRES/CELL)+j] - th_ogravmap[i*(XRES/CELL)+j];
#else
val = th_gravmap[i*(XRES/CELL)+j];
#endif
th_gravx[y*(XRES/CELL)+x] += M_GRAV * val * (j - x) / pow(distance, 3.0f);
th_gravy[y*(XRES/CELL)+x] += M_GRAV * val * (i - y) / pow(distance, 3.0f);
th_gravp[y*(XRES/CELL)+x] += M_GRAV * val / pow(distance, 2.0f);
}
}
}
}
}
fin:
memcpy(th_ogravmap, th_gravmap, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memcpy(obmap, bmap, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned char));
}
#endif
void Gravity::grav_mask_r(int x, int y, char checkmap[YRES/CELL][XRES/CELL], char shape[YRES/CELL][XRES/CELL], char *shapeout)
{
if(x < 0 || x >= XRES/CELL || y < 0 || y >= YRES/CELL)
return;
if(x == 0 || y ==0 || y == (YRES/CELL)-1 || x == (XRES/CELL)-1)
*shapeout = 1;
int x1 = x, x2 = x;
while (x1 >= 1)
{
if(checkmap[y][x1-1] || bmap[y][x1-1]==WL_GRAV)
break;
x1--;
}
while (x2 < (XRES/CELL)-1)
{
if(checkmap[y][x2+1] || bmap[y][x2+1]==WL_GRAV)
break;
x2++;
}
// fill span
for (x = x1; x <= x2; x++)
checkmap[y][x] = shape[y][x] = 1;
if(y >= 1)
for(x = x1; x <= x2; x++)
if(!checkmap[y-1][x] && bmap[y-1][x]!=WL_GRAV)
grav_mask_r(x, y-1, checkmap, shape, shapeout);
if(y < (YRES/CELL)-1)
for(x = x1; x <= x2; x++)
if(!checkmap[y+1][x] && bmap[y+1][x]!=WL_GRAV)
grav_mask_r(x, y+1, checkmap, shape, shapeout);
return;
}
void Gravity::mask_free(mask_el *c_mask_el){
if(c_mask_el==NULL)
return;
if(c_mask_el->next!=NULL)
mask_free((mask_el*)c_mask_el->next);
free(c_mask_el->shape);
free(c_mask_el);
}
void Gravity::gravity_mask()
{
char checkmap[YRES/CELL][XRES/CELL];
int x = 0, y = 0;
unsigned maskvalue;
mask_el *t_mask_el = NULL;
mask_el *c_mask_el = NULL;
if(!gravmask)
return;
memset(checkmap, 0, sizeof(checkmap));
for(x = 0; x < XRES/CELL; x++)
{
for(y = 0; y < YRES/CELL; y++)
{
if(bmap[y][x]!=WL_GRAV && checkmap[y][x] == 0)
{
//Create a new shape
if(t_mask_el==NULL){
t_mask_el = (mask_el *)malloc(sizeof(mask_el));
t_mask_el->shape = (char *)malloc((XRES/CELL)*(YRES/CELL));
memset(t_mask_el->shape, 0, (XRES/CELL)*(YRES/CELL));
t_mask_el->shapeout = 0;
t_mask_el->next = NULL;
c_mask_el = t_mask_el;
} else {
c_mask_el->next = (mask_el *)malloc(sizeof(mask_el));
c_mask_el = (mask_el *)c_mask_el->next;
c_mask_el->shape = (char *)malloc((XRES/CELL)*(YRES/CELL));
memset(c_mask_el->shape, 0, (XRES/CELL)*(YRES/CELL));
c_mask_el->shapeout = 0;
c_mask_el->next = NULL;
}
//Fill the shape
grav_mask_r(x, y, (char (*)[XRES/CELL])checkmap, (char (*)[XRES/CELL])c_mask_el->shape, (char*)&c_mask_el->shapeout);
}
}
}
c_mask_el = t_mask_el;
memset(gravmask, 0, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
while(c_mask_el!=NULL)
{
char *cshape = c_mask_el->shape;
for(x = 0; x < XRES/CELL; x++)
{
for(y = 0; y < YRES/CELL; y++)
{
if(cshape[y*(XRES/CELL)+x]){
if(c_mask_el->shapeout)
maskvalue = 0xFFFFFFFF;
else
maskvalue = 0x00000000;
gravmask[y*(XRES/CELL)+x] = maskvalue;
}
}
}
c_mask_el = (mask_el*)c_mask_el->next;
}
mask_free(t_mask_el);
}
