static int inline get_distance_xy( INSTANCE * a, int x2, int y2, int r2 )
{
if ( a )
{
int x1, y1;
int res = LOCINT32( mod_grproc, a, RESOLUTION ) ;
x1 = LOCINT32( mod_grproc, a, COORDX ) ;
y1 = LOCINT32( mod_grproc, a, COORDY ) ;
RESOLXY( mod_grproc, a, x1, y1 );
RESOLXY_RES( x2, y2, r2 );
double dx = ( x2 - x1 ) * ( x2 - x1 ) ;
double dy = ( y2 - y1 ) * ( y2 - y1 ) ;
if ( res > 0 ) return ( int )sqrt( dx + dy ) * res ;
else if ( res < 0 ) return ( int )sqrt( dx + dy ) / -res ;
return ( int )sqrt( dx + dy ) ;
}
return -1 ;
}
void instance_get_bbox( INSTANCE * i, GRAPH * gr, REGION * dest )
{
REGION *region;
int x, y, r ;
int scalex, scaley ;
r = LOCINT32( librender, i, REGIONID ) ;
if ( r > 0 && r < 32 )
region = ®ions[ r ] ;
else
region = ®ions[ 0 ];
x = LOCINT32( librender, i, COORDX ) ;
y = LOCINT32( librender, i, COORDY ) ;
RESOLXY( librender, i, x, y );
scalex = LOCINT32( librender, i, GRAPHSIZEX );
scaley = LOCINT32( librender, i, GRAPHSIZEY );
if ( scalex == 100 && scaley == 100 ) scalex = scaley = LOCINT32( librender, i, GRAPHSIZE );
gr_get_bbox( dest,
region,
x,
y,
LOCDWORD( librender, i, FLAGS ) ^ LOCDWORD( librender, i, XGRAPH_FLAGS ),
LOCDWORD( librender, i, XGRAPH ) ? 0 : LOCINT32( librender, i, ANGLE ),
scalex,
scaley,
gr
) ;
}
static int get_bbox( REGION * bbox, INSTANCE * proc )
{
GRAPH * b ;
int x, y ;
int scalex, scaley ;
b = instance_graph( proc ) ;
if ( !b ) return 0 ;
scalex = LOCINT32( mod_grproc, proc, GRAPHSIZEX );
scaley = LOCINT32( mod_grproc, proc, GRAPHSIZEY );
if ( scalex == 100 && scaley == 100 ) scalex = scaley = LOCINT32( mod_grproc, proc, GRAPHSIZE );
x = LOCINT32( mod_grproc, proc, COORDX ) ;
y = LOCINT32( mod_grproc, proc, COORDY ) ;
RESOLXY( mod_grproc, proc, x, y );
gr_get_bbox( bbox, 0, x, y, LOCDWORD( mod_grproc, proc, FLAGS ) & ( B_HMIRROR | B_VMIRROR ), LOCINT32( mod_grproc, proc, ANGLE ), scalex, scaley, b ) ;
return 1 ;
}
void scroll_draw( int n, REGION * clipping )
{
int nproc, x, y, cx, cy ;
static INSTANCE ** proclist = 0;
static int proclist_reserved = 0;
int proclist_count;
REGION r;
int status;
GRAPH * graph, * back, * dest = NULL;
SCROLL_EXTRA_DATA * data;
INSTANCE * i;
if ( n < 0 || n > 9 ) return ;
if ( !scrolls[n].active || !scrolls[n].region || !scrolls[n].graphid ) return ;
graph = scrolls[n].graphid ? bitmap_get( scrolls[n].fileid, scrolls[n].graphid ) : NULL ;
back = scrolls[n].backid ? bitmap_get( scrolls[n].fileid, scrolls[n].backid ) : NULL ;
if ( !graph ) return ; // El fondo de scroll no existe
if ( scrolls[n].backid && !back ) return ; // Grafico no existe
dest = scrolls[n].destid ? bitmap_get( scrolls[n].destfile, scrolls[n].destid ) : NULL ;
data = &(( SCROLL_EXTRA_DATA * ) & GLODWORD( libscroll, SCROLLS ) )[n] ;
/* Dibuja el fondo */
r = *scrolls[n].region;
if ( !dest && clipping ) region_union( &r, clipping );
if ( back )
{
if ( back->ncpoints > 0 && back->cpoints[0].x >= 0 )
{
cx = back->cpoints[0].x ;
cy = back->cpoints[0].y ;
}
else
{
cx = back->width / 2 ;
cy = back->height / 2 ;
}
y = scrolls[n].region->y - scrolls[n].y1 ;
while ( y < scrolls[n].region->y2 )
{
x = scrolls[n].region->x - scrolls[n].x1 ;
while ( x < scrolls[n].region->x2 )
{
gr_blit( dest, &r, x + cx, y + cy, data->flags2, back ) ;
x += back->width ;
}
y += back->height ;
}
}
/* Dibuja el primer plano */
if ( graph->ncpoints > 0 && graph->cpoints[0].x >= 0 )
{
cx = graph->cpoints[0].x ;
cy = graph->cpoints[0].y ;
}
else
{
cx = graph->width / 2 ;
cy = graph->height / 2 ;
}
y = scrolls[n].region->y - scrolls[n].y0 ;
while ( y < scrolls[n].region->y2 )
{
x = scrolls[n].region->x - scrolls[n].x0 ;
while ( x < scrolls[n].region->x2 )
{
gr_blit( dest, &r, x + cx, y + cy, data->flags1, graph ) ;
x += graph->width ;
}
y += graph->height ;
}
/* Crea una lista ordenada de instancias a dibujar */
i = first_instance ;
proclist_count = 0 ;
while ( i )
{
if ( LOCDWORD( libscroll, i, CTYPE ) == C_SCROLL &&
(
(( status = LOCDWORD( libscroll, i, STATUS ) ) & ~STATUS_WAITING_MASK ) == STATUS_RUNNING ||
( status & ~STATUS_WAITING_MASK ) == STATUS_FROZEN
)
)
{
if ( LOCDWORD( libscroll, i, CNUMBER ) && !( LOCDWORD( libscroll, i, CNUMBER ) & ( 1 << n ) ) )
{
i = i->next ;
continue ;
}
if ( proclist_count == proclist_reserved )
{
proclist_reserved += 16 ;
proclist = ( INSTANCE ** ) realloc( proclist, sizeof( INSTANCE * ) * proclist_reserved ) ;
}
proclist[proclist_count++] = i ;
}
i = i->next ;
}
if ( proclist_count )
{
/* Ordena la listilla */
qsort( proclist, proclist_count, sizeof( INSTANCE * ), compare_instances ) ;
/* Visualiza los procesos */
for ( nproc = 0 ; nproc < proclist_count ; nproc++ )
{
x = LOCDWORD( libscroll, proclist[nproc], COORDX ) ;
y = LOCDWORD( libscroll, proclist[nproc], COORDY ) ;
RESOLXY( libscroll, proclist[nproc], x, y );
draw_instance_at( proclist[nproc], &r, x - scrolls[n].posx0 + scrolls[n].region->x, y - scrolls[n].posy0 + scrolls[n].region->y, dest ) ;
}
}
}
void scroll_update( int n )
{
int x0, y0, x1, y1, cx, cy, w, h, speed ;
REGION bbox;
GRAPH * gr, * graph, * back;
SCROLL_EXTRA_DATA * data;
if ( n < 0 || n > 9 ) return ;
if ( !scrolls[n].active || !scrolls[n].region || !scrolls[n].graphid ) return ;
graph = scrolls[n].graphid ? bitmap_get( scrolls[n].fileid, scrolls[n].graphid ) : 0 ;
back = scrolls[n].backid ? bitmap_get( scrolls[n].fileid, scrolls[n].backid ) : 0 ;
if ( !graph ) return ; // El fondo de scroll no existe
if ( scrolls[n].backid && !back ) return ; // Grafico no existe
data = &(( SCROLL_EXTRA_DATA * ) &GLODWORD( libscroll, SCROLLS ) )[n] ;
w = scrolls[n].region->x2 - scrolls[n].region->x + 1 ;
h = scrolls[n].region->y2 - scrolls[n].region->y + 1 ;
scrolls[n].z = data->z ;
scrolls[n].ratio = data->ratio ;
scrolls[n].camera = instance_get( data->camera ) ;
scrolls[n].speed = data->speed ;
if ( data->follows < 0 || data->follows > 9 )
scrolls[n].follows = 0 ;
else
scrolls[n].follows = &scrolls[data->follows] ;
if ( data->region1 < 0 || data->region1 > 31 )
scrolls[n].region1 = 0 ;
else
scrolls[n].region1 = ®ions[data->region1] ;
if ( data->region2 < 0 || data->region2 > 31 )
scrolls[n].region2 = 0 ;
else
scrolls[n].region2 = ®ions[data->region2] ;
/* Actualiza las variables globales (perseguir la camara, etc) */
if ( scrolls[n].follows )
{
if ( scrolls[n].ratio )
{
data->x0 = scrolls[n].follows->x0 * 100 / scrolls[n].ratio ;
data->y0 = scrolls[n].follows->y0 * 100 / scrolls[n].ratio ;
}
else
{
data->x0 = scrolls[n].follows->x0 ;
data->y0 = scrolls[n].follows->y0 ;
}
}
if ( scrolls[n].camera )
{
/* Mira a ver si entra dentro de la region 1 o 2 */
speed = scrolls[n].speed ;
if ( scrolls[n].speed == 0 ) speed = 9999999 ;
/* Update speed */
if (( gr = instance_graph( scrolls[n].camera ) ) )
{
instance_get_bbox( scrolls[n].camera, gr, &bbox );
x0 = bbox.x - data->x0 ;
y0 = bbox.y - data->y0 ;
x1 = bbox.x2 - data->x0 ;
y1 = bbox.y2 - data->y0 ;
if ( scrolls[n].region1 &&
(
x0 < scrolls[n].region1->x2 && y0 < scrolls[n].region1->y2 &&
x1 > scrolls[n].region1->x && y1 > scrolls[n].region1->y
)
)
{
speed = 0 ;
}
else
if ( scrolls[n].region2 )
{
if ( x0 > scrolls[n].region2->x2 ) speed = ( x0 - scrolls[n].region2->x2 );
if ( y0 > scrolls[n].region2->y2 ) speed = ( y0 - scrolls[n].region2->y2 );
if ( x1 < scrolls[n].region2->x ) speed = ( scrolls[n].region2->x - x1 );
if ( y1 < scrolls[n].region2->y ) speed = ( scrolls[n].region2->y - y1 );
}
}
/* Forzar a que esté en el centro de la ventana */
cx = LOCDWORD( libscroll, scrolls[n].camera, COORDX ) ;
cy = LOCDWORD( libscroll, scrolls[n].camera, COORDY ) ;
RESOLXY( libscroll, scrolls[n].camera, cx, cy );
cx -= w / 2 ;
cy -= h / 2 ;
if ( data->x0 < cx ) data->x0 = MIN( data->x0 + speed, cx ) ;
if ( data->y0 < cy ) data->y0 = MIN( data->y0 + speed, cy ) ;
if ( data->x0 > cx ) data->x0 = MAX( data->x0 - speed, cx ) ;
if ( data->y0 > cy ) data->y0 = MAX( data->y0 - speed, cy ) ;
}
/* Scrolls no cíclicos y posición del background */
if ( graph )
{
if ( !( scrolls[n].flags & GRAPH_HWRAP ) ) data->x0 = MAX( 0, MIN( data->x0, ( int )graph->width - w ) ) ;
if ( !( scrolls[n].flags & GRAPH_VWRAP ) ) data->y0 = MAX( 0, MIN( data->y0, ( int )graph->height - h ) ) ;
}
if ( scrolls[n].ratio )
{
data->x1 = data->x0 * 100 / scrolls[n].ratio ;
data->y1 = data->y0 * 100 / scrolls[n].ratio ;
}
if ( back )
{
if ( !( scrolls[n].flags & BACK_HWRAP ) ) data->x1 = MAX( 0, MIN( data->x1, ( int )back->width - w ) ) ;
if ( !( scrolls[n].flags & BACK_VWRAP ) ) data->y1 = MAX( 0, MIN( data->y1, ( int )back->height - h ) ) ;
}
/* Actualiza la posición del scroll según las variables globales */
scrolls[n].posx0 = data->x0 ;
scrolls[n].posy0 = data->y0 ;
scrolls[n].x0 = data->x0 % ( int32_t ) graph->width ;
scrolls[n].y0 = data->y0 % ( int32_t ) graph->height ;
if ( scrolls[n].x0 < 0 ) scrolls[n].x0 += graph->width ;
if ( scrolls[n].y0 < 0 ) scrolls[n].y0 += graph->height ;
if ( back )
{
scrolls[n].x1 = data->x1 % ( int32_t ) back->width ;
scrolls[n].y1 = data->y1 % ( int32_t ) back->height ;
if ( scrolls[n].x1 < 0 ) scrolls[n].x1 += back->width ;
if ( scrolls[n].y1 < 0 ) scrolls[n].y1 += back->height ;
}
}
static int check_collision( INSTANCE * proc1, GRAPH * bmp1, REGION * bbox3, INSTANCE * proc2 )
{
REGION bbox1, bbox2 ;
int x, y, w, h ;
GRAPH * bmp2 ;
bbox1 = *bbox3;
bmp2 = instance_graph( proc2 ) ; if ( !bmp2 ) return 0 ;
instance_get_bbox( proc2, bmp2, &bbox2 );
region_union( &bbox1, &bbox2 ) ;
if ( region_is_empty( &bbox1 ) ) return 0 ;
// Solo si las regiones de ambos bbox se superponen
w = bbox1.x2 - bbox1.x + 1 ;
h = bbox1.y2 - bbox1.y + 1 ;
bbox2.x = bbox2.y = 0 ;
bbox2.x2 = w - 1 ;
bbox2.y2 = h - 1 ;
bmp1 = bitmap_new( 0, w, h, sys_pixel_format->depth ) ;
if ( !bmp1 ) return 0;
bmp2 = bitmap_new( 0, w, h, sys_pixel_format->depth ) ;
if ( !bmp2 )
{
bitmap_destroy( bmp1 ) ;
return 0;
}
memset( bmp1->data, 0, bmp1->pitch * h ) ;
memset( bmp2->data, 0, bmp2->pitch * h ) ;
x = LOCINT32( mod_grproc, proc1, COORDX ) ;
y = LOCINT32( mod_grproc, proc1, COORDY ) ;
RESOLXY( mod_grproc, proc1, x, y );
x -= bbox1.x ;
y -= bbox1.y ;
draw_at( bmp1, x, y, &bbox2, proc1 ) ;
x = LOCINT32( mod_grproc, proc2, COORDX ) ;
y = LOCINT32( mod_grproc, proc2, COORDY ) ;
RESOLXY( mod_grproc, proc2, x, y );
x -= bbox1.x ;
y -= bbox1.y ;
draw_at( bmp2, x, y, &bbox2, proc2 ) ;
if ( sys_pixel_format->depth == 32 )
{
uint32_t * ptr1 = ( uint32_t * ) bmp1->data ;
uint32_t * ptr2 = ( uint32_t * ) bmp2->data ;
uint8_t * _ptr1 = ( uint8_t * ) ptr1 ;
uint8_t * _ptr2 = ( uint8_t * ) ptr2 ;
for ( y = 0 ; y < h ; y++ )
{
for ( x = 0 ; x < w ; x++, ptr1++, ptr2++ )
{
if ( *ptr1 && *ptr2 )
{
bitmap_destroy( bmp1 ) ;
bitmap_destroy( bmp2 ) ;
return 1;
}
}
ptr1 = ( uint32_t * )( _ptr1 += bmp1->pitch );
ptr2 = ( uint32_t * )( _ptr2 += bmp2->pitch );
}
}
else
{
if ( sys_pixel_format->depth == 16 )
{
uint16_t * ptr1 = ( uint16_t * ) bmp1->data ;
uint16_t * ptr2 = ( uint16_t * ) bmp2->data ;
uint8_t * _ptr1 = ( uint8_t * ) ptr1 ;
uint8_t * _ptr2 = ( uint8_t * ) ptr2 ;
for ( y = 0 ; y < h ; y++ )
{
for ( x = 0 ; x < w ; x++, ptr1++, ptr2++ )
{
if ( *ptr1 && *ptr2 )
{
bitmap_destroy( bmp1 ) ;
bitmap_destroy( bmp2 ) ;
return 1;
}
}
ptr1 = ( uint16_t * )( _ptr1 += bmp1->pitch );
ptr2 = ( uint16_t * )( _ptr2 += bmp2->pitch );
}
}
else
{
uint8_t * ptr1 = ( uint8_t * )bmp1->data ;
uint8_t * ptr2 = ( uint8_t * )bmp2->data ;
uint8_t * _ptr1 = ptr1 ;
uint8_t * _ptr2 = ptr2 ;
for ( y = 0 ; y < h ; y++ )
{
for ( x = 0 ; x < w ; x++, ptr1++, ptr2++ )
{
if ( *ptr1 && *ptr2 )
{
bitmap_destroy( bmp1 ) ;
bitmap_destroy( bmp2 ) ;
return 1;
}
}
ptr1 = _ptr1 += bmp1->pitch;
ptr2 = _ptr2 += bmp2->pitch;
}
}
}
bitmap_destroy( bmp1 ) ;
bitmap_destroy( bmp2 ) ;
return 0;
}
static int check_collision_with_mouse( INSTANCE * proc1, int colltype )
{
REGION bbox1, bbox2 ;
int x, y, mx, my ;
static GRAPH * bmp = NULL;
switch ( colltype )
{
case COLLISION_BOX:
case COLLISION_CIRCLE:
if ( !get_bbox( &bbox2, proc1 ) ) return 0 ;
case COLLISION_NORMAL:
break;
default:
return 0;
}
mx = GLOINT32( mod_grproc, MOUSEX ) ;
my = GLOINT32( mod_grproc, MOUSEY ) ;
/* Checks the process's bounding box to optimize checking
(only for screen-type objects) */
if ( LOCDWORD( mod_grproc, proc1, CTYPE ) == C_SCREEN )
{
switch ( colltype )
{
case COLLISION_NORMAL:
if ( !get_bbox( &bbox2, proc1 ) ) return 0 ;
if ( bbox2.x > mx || bbox2.x2 < mx || bbox2.y > my || bbox2.y2 < my ) return 0 ;
break;
case COLLISION_BOX:
if ( bbox2.x <= mx && bbox2.x2 >= mx && bbox2.y <= my && bbox2.y2 >= my ) return 1;
return 0;
break;
case COLLISION_CIRCLE:
{
int cx1, cy1, dx1, dy1;
cx1 = bbox2.x + ( dx1 = ( bbox2.x2 - bbox2.x + 1 ) ) / 2 ;
cy1 = bbox2.y + ( dy1 = ( bbox2.y2 - bbox2.y + 1 ) ) / 2 ;
if ( get_distance( cx1, cy1, 0, mx, my, 0 ) < ( dx1 + dy1 ) / 4 ) return 1;
return 0;
break;
}
}
}
/* Creates a temporary bitmap (only once) */
if ( colltype == COLLISION_NORMAL )
{
/* maybe must force this to 32 bits */
if ( bmp && bmp->format->depth != sys_pixel_format->depth ) { bitmap_destroy( bmp ); bmp = NULL; }
if ( !bmp ) bmp = bitmap_new( 0, 2, 1, sys_pixel_format->depth ) ;
if ( !bmp ) return 0 ;
memset( bmp->data, 0, bmp->pitch * bmp->height ) ;
}
/* Retrieves process information */
bbox1.x = 0 ; bbox1.x2 = 1 ;
bbox1.y = 0 ; bbox1.y2 = 0 ;
x = LOCINT32( mod_grproc, proc1, COORDX ) ;
y = LOCINT32( mod_grproc, proc1, COORDY ) ;
RESOLXY( mod_grproc, proc1, x, y );
/* Scroll-type process: check for each region */
if ( LOCDWORD( mod_grproc, proc1, CTYPE ) == C_SCROLL )
{
SCROLL_EXTRA_DATA * data;
scrolldata * scroll;
int i;
if ( GLOEXISTS( mod_grproc, SCROLLS ) )
{
int cnumber = LOCDWORD( mod_grproc, proc1, CNUMBER );
if ( !cnumber ) cnumber = 0xffffffff ;
for ( i = 0 ; i < 10 ; i++ )
{
data = &(( SCROLL_EXTRA_DATA * ) & GLODWORD( mod_grproc, SCROLLS ) )[i] ;
scroll = ( scrolldata * ) data->reserved[0];
if ( scroll && scroll->active && ( cnumber & ( 1 << i ) ) )
{
REGION * r = scroll->region;
switch ( colltype )
{
case COLLISION_NORMAL:
if ( r->x > mx || r->x2 < mx || r->y > my || r->y2 < my ) continue;
draw_at( bmp, x + r->x - mx - scroll->posx0, y + r->y - my - scroll->posy0, &bbox1, proc1 );
switch ( sys_pixel_format->depth )
{
case 8:
if ( *( uint8_t * )bmp->data ) return 1;
break;
case 16:
if ( *( uint16_t * )bmp->data ) return 1;
break;
case 32:
if ( *( uint32_t * )bmp->data ) return 1;
break;
}
break;
case COLLISION_BOX:
if ( bbox2.x <= scroll->posx0 + r->x + mx && bbox2.x2 >= scroll->posx0 + r->x + mx &&
bbox2.y <= scroll->posy0 + r->y + my && bbox2.y2 >= scroll->posy0 + r->y + my ) return 1;
break;
case COLLISION_CIRCLE:
{
int cx1, cy1, dx1, dy1;
cx1 = bbox2.x + ( dx1 = ( bbox2.x2 - bbox2.x + 1 ) ) / 2 ;
cy1 = bbox2.y + ( dy1 = ( bbox2.y2 - bbox2.y + 1 ) ) / 2 ;
if ( get_distance( cx1, cy1, 0, r->x + mx + scroll->posx0, r->y + my + scroll->posy0, 0 ) < ( dx1 + dy1 ) / 4 ) return 1;
break;
}
}
}
}
}
return 0;
}
switch ( colltype )
{
case COLLISION_NORMAL:
/* Collision check (blits into temporary space and checks the resulting pixel) */
draw_at( bmp, x - mx, y - my, &bbox1, proc1 ) ;
switch ( sys_pixel_format->depth )
{
case 8:
if ( *( uint8_t * )bmp->data ) return 1;
break;
case 16:
if ( *( uint16_t * )bmp->data ) return 1;
break;
case 32:
if ( *( uint32_t * )bmp->data ) return 1;
break;
}
break;
case COLLISION_BOX:
if ( bbox2.x <= mx && bbox2.x2 >= mx &&
bbox2.y <= my && bbox2.y2 >= my ) return 1;
break;
case COLLISION_CIRCLE:
{
int cx1, cy1, dx1, dy1;
cx1 = bbox2.x + ( dx1 = ( bbox2.x2 - bbox2.x + 1 ) ) / 2 ;
cy1 = bbox2.y + ( dy1 = ( bbox2.y2 - bbox2.y + 1 ) ) / 2 ;
if ( get_distance( cx1, cy1, 0, mx, my, 0 ) < ( dx1 + dy1 ) / 4 ) return 1;
break;
}
}
return 0 ;
}
static int grproc_get_real_point( INSTANCE * my, int * params )
{
GRAPH * b ;
int x, y, r, centerx, centery, px = 0, py = 0, rx = 0, ry = 0 ;
int _angle = 0, angle = 0;
b = instance_graph( my ) ;
if ( !b ) return 0 ;
/* Point 0 is the graphic center, but it may be not defined */
if ( params[0] == 0 && ( b->ncpoints == 0 || b->cpoints[0].x == CPOINT_UNDEFINED ) )
{
if ( b->ncpoints == 0 )
bitmap_add_cpoint( b, b->width / 2, b->height / 2 );
else
{
b->cpoints[0].x = b->width / 2;
b->cpoints[0].y = b->height / 2;
}
}
else
if (( uint32_t )params[0] >= b->ncpoints || params[0] < 0)
return 0 ;
if ( b->cpoints[params[0]].x == CPOINT_UNDEFINED && b->cpoints[params[0]].y == CPOINT_UNDEFINED )
return 0;
r = LOCINT32( mod_grproc, my, REGIONID ) ;
if ( r < 0 || r > 31 ) r = 0 ;
if ( b->cpoints[0].x != CPOINT_UNDEFINED && b->cpoints[0].y != CPOINT_UNDEFINED )
{
centerx = b->cpoints[0].x ;
centery = b->cpoints[0].y ;
}
else
{
centerx = b->width / 2 ;
centery = b->height / 2 ;
}
if ( LOCINT32( mod_grproc, my, ANGLE ) != 0 && !LOCDWORD( mod_grproc, my, XGRAPH ) )
{
_angle = angle = LOCINT32( mod_grproc, my, ANGLE ) ;
}
/* if ( b->cpoints[params[0]].x >= 0 )
{
if ( LOCDWORD( mod_grproc, my, FLAGS ) & B_HMIRROR )
px = centerx - b->cpoints[params[0]].x - 1 ;
else
px = b->cpoints[params[0]].x - centerx ;
if ( LOCDWORD( mod_grproc, my, FLAGS ) & B_VMIRROR )
py = centery - b->cpoints[params[0]].y - 1 ;
else
py = b->cpoints[params[0]].y - centery ;
}
else
px = py = 0 ; */
if ( params[0] > 0 )
{
px = b->cpoints[params[0]].x - centerx ;
py = b->cpoints[params[0]].y - centery ;
if ( LOCDWORD( mod_grproc, my, FLAGS ) & B_HMIRROR )
{
if (_angle)
{
py = (centery - b->cpoints[params[0]].y) ;
angle = 90000 + ( 90000 - angle );
}
else
px = (centerx - b->cpoints[params[0]].x) ;
}
if ( LOCDWORD( mod_grproc, my, FLAGS ) & B_VMIRROR )
{
if (_angle)
{
px = (centerx - b->cpoints[params[0]].x) ;
angle = 360000 + ( 180000 - angle );
}
else
py = (centery - b->cpoints[params[0]].y) ;
}
}
if ( LOCINT32( mod_grproc, my, GRAPHSIZEX ) == 100 && LOCINT32( mod_grproc, my, GRAPHSIZEY ) == 100 )
{
if ((( int )LOCINT32( mod_grproc, my, GRAPHSIZE ) ) > 0 )
{
// Corrected a bug from the casting that rounded to 0
px = ( int )( px * ( LOCINT32( mod_grproc, my, GRAPHSIZE ) / 100.0F ) ) ;
py = ( int )( py * ( LOCINT32( mod_grproc, my, GRAPHSIZE ) / 100.0F ) ) ;
}
}
else
{
// Adding size_x/size_y control
if ( LOCINT32( mod_grproc, my, GRAPHSIZEX ) > 0 )
px = ( int )( px * ( LOCINT32( mod_grproc, my, GRAPHSIZEX ) / 100.0F ) ) ;
if ( LOCINT32( mod_grproc, my, GRAPHSIZEY ) > 0 )
py = ( int )( py * ( LOCINT32( mod_grproc, my, GRAPHSIZEY ) / 100.0F ) ) ;
}
if ( angle )
{
float cos_angle = ( float ) cos( angle * M_PI / -180000.0 );
float sin_angle = ( float ) sin( angle * M_PI / -180000.0 );
rx = ( int )(( double )px * cos_angle - ( double )py * sin_angle ) ;
ry = ( int )(( double )px * sin_angle + ( double )py * cos_angle ) ;
px = rx ;
py = ry ;
}
x = LOCINT32( mod_grproc, my, COORDX ) ;
y = LOCINT32( mod_grproc, my, COORDY ) ;
RESOLXY( mod_grproc, my, x, y );
rx = x + px ;
ry = y + py ;
if ( LOCINT32( mod_grproc, my, RESOLUTION ) > 0 )
{
rx *= LOCINT32( mod_grproc, my, RESOLUTION );
ry *= LOCINT32( mod_grproc, my, RESOLUTION );
}
else if ( LOCINT32( mod_grproc, my, RESOLUTION ) < 0 )
{
rx /= -LOCINT32( mod_grproc, my, RESOLUTION );
ry /= -LOCINT32( mod_grproc, my, RESOLUTION );
}
*( int * )params[1] = rx ;
*( int * )params[2] = ry ;
return 1 ;
}
int draw_instance_info( INSTANCE * i, REGION * region, int * z, int * drawme )
{
GRAPH * graph;
* drawme = 0;
LOCDWORD( librender, i, GRAPHPTR ) = ( int )( graph = instance_graph( i ) );
if ( !graph )
{
/*
region->x = -2; region->y = -2;
region->x2 = -2; region->y2 = -2;
*/
return 0;
}
int changed;
int status;
int coordz, coordx, coordy;
status = ( LOCDWORD( librender, i, STATUS ) & ~STATUS_WAITING_MASK ) ;
coordz = LOCINT32( librender, i, COORDZ );
/* Si tiene grafico o xgraph o (ctype == 0 y esta corriendo o congelado) */
if ( LOCDWORD( librender, i, CTYPE ) == C_SCREEN && ( status == STATUS_RUNNING || status == STATUS_FROZEN ) )
* drawme = 1;
coordx = LOCINT32( librender, i, COORDX );
coordy = LOCINT32( librender, i, COORDY );
RESOLXY( librender, i, coordx, coordy );
changed =
graph->modified ||
LOCINT32( librender, i, SAVED_COORDX ) != coordx ||
LOCINT32( librender, i, SAVED_COORDY ) != coordy ||
LOCINT32( librender, i, SAVED_COORDZ ) != coordz ||
LOCDWORD( librender, i, SAVED_GRAPHID ) != LOCDWORD( librender, i, GRAPHID ) ||
LOCINT32( librender, i, SAVED_ANGLE ) != LOCINT32( librender, i, ANGLE ) ||
LOCDWORD( librender, i, SAVED_ALPHA ) != LOCDWORD( librender, i, ALPHA ) ||
LOCDWORD( librender, i, SAVED_BLENDOP ) != LOCDWORD( librender, i, BLENDOP ) ||
LOCINT32( librender, i, SAVED_GRAPHSIZE ) != LOCINT32( librender, i, GRAPHSIZE ) ||
LOCINT32( librender, i, SAVED_GRAPHSIZEX ) != LOCINT32( librender, i, GRAPHSIZEX ) ||
LOCINT32( librender, i, SAVED_GRAPHSIZEY ) != LOCINT32( librender, i, GRAPHSIZEY ) ||
LOCDWORD( librender, i, SAVED_FLAGS ) != LOCDWORD( librender, i, FLAGS ) ||
LOCDWORD( librender, i, SAVED_FILEID ) != LOCDWORD( librender, i, FILEID ) ||
LOCDWORD( librender, i, SAVED_XGRAPH ) != LOCDWORD( librender, i, XGRAPH ) ||
(
graph->ncpoints &&
(
LOCDWORD( librender, i, SAVED_CENTERX ) != graph->cpoints[0].x ||
LOCDWORD( librender, i, SAVED_CENTERY ) != graph->cpoints[0].y
)
)
;
if ( changed )
{
/* Update key */
* z = coordz;
LOCINT32( librender, i, SAVED_COORDX ) = coordx;
LOCINT32( librender, i, SAVED_COORDY ) = coordy;
LOCINT32( librender, i, SAVED_COORDZ ) = coordz;
LOCDWORD( librender, i, SAVED_GRAPHID ) = LOCDWORD( librender, i, GRAPHID );
LOCINT32( librender, i, SAVED_ANGLE ) = LOCINT32( librender, i, ANGLE );
LOCDWORD( librender, i, SAVED_ALPHA ) = LOCDWORD( librender, i, ALPHA );
LOCDWORD( librender, i, SAVED_BLENDOP ) = LOCDWORD( librender, i, BLENDOP );
LOCINT32( librender, i, SAVED_GRAPHSIZE ) = LOCINT32( librender, i, GRAPHSIZE );
LOCINT32( librender, i, SAVED_GRAPHSIZEX ) = LOCINT32( librender, i, GRAPHSIZEX );
LOCINT32( librender, i, SAVED_GRAPHSIZEY ) = LOCINT32( librender, i, GRAPHSIZEY );
LOCDWORD( librender, i, SAVED_FLAGS ) = LOCDWORD( librender, i, FLAGS );
LOCDWORD( librender, i, SAVED_FILEID ) = LOCDWORD( librender, i, FILEID );
LOCDWORD( librender, i, SAVED_XGRAPH ) = LOCDWORD( librender, i, XGRAPH );
if ( graph->ncpoints )
{
LOCDWORD( librender, i, SAVED_CENTERX ) = graph->cpoints[0].x;
LOCDWORD( librender, i, SAVED_CENTERY ) = graph->cpoints[0].y;
}
else
{
LOCDWORD( librender, i, SAVED_CENTERX ) = CPOINT_UNDEFINED;
LOCDWORD( librender, i, SAVED_CENTERY ) = CPOINT_UNDEFINED;
}
instance_get_bbox( i, graph, region );
return 1;
}
return changed;
}
void draw_instance( INSTANCE * i, REGION * clip )
{
GRAPH * map ;
int16_t * blend_table = NULL ;
int flags;
int scalex, scaley;
REGION region;
int alpha ;
int blendop = 0 ;
PALETTE * palette = NULL ;
int paletteid;
/* Difference with draw_instance_at from here */
int x, y, r ;
/* Difference with draw_instance_at to here */
// map = instance_graph( i ) ;
map = ( GRAPH * ) LOCDWORD( librender, i, GRAPHPTR );
if ( !map ) return ;
flags = ( LOCDWORD( librender, i, FLAGS ) ^ LOCDWORD( librender, i, XGRAPH_FLAGS ) );
if (( alpha = LOCDWORD( librender, i, ALPHA ) ) != 255 )
{
if ( alpha <= 0 ) return ;
else if ( alpha < 255 )
flags |= B_ALPHA | ( alpha << B_ALPHA_SHIFT );
}
scalex = LOCINT32( librender, i, GRAPHSIZEX );
scaley = LOCINT32( librender, i, GRAPHSIZEY );
if ( scalex == 100 && scaley == 100 ) scalex = scaley = LOCINT32( librender, i, GRAPHSIZE );
if (( blendop = LOCDWORD( librender, i, BLENDOP ) ) )
{
blend_table = map->blend_table;
map->blend_table = ( int16_t * ) blendop;
}
if (( paletteid = LOCDWORD( librender, i, PALETTEID ) ) )
{
palette = map->format->palette ;
map->format->palette = ( PALETTE * ) paletteid;
}
/* Difference with draw_instance_at from here */
x = LOCINT32( librender, i, COORDX ) ;
y = LOCINT32( librender, i, COORDY ) ;
RESOLXY( librender, i, x, y );
r = LOCINT32( librender, i, REGIONID ) ;
if ( r > 0 && r < 32 )
region = regions[ r ] ;
else
region = regions[ 0 ];
if ( clip ) region_union( ®ion, clip );
/* Difference with draw_instance_at to here */
/* XGRAPH does not rotate destination graphic.
WARNING: don't remove "scalex != 100 || scaley != 100 ||" from begin the next condition */
if ( scalex != 100 || scaley != 100 || ( LOCINT32( librender, i, ANGLE ) && !LOCDWORD( librender, i, XGRAPH ) ) )
gr_rotated_blit( 0, ®ion, x, y, flags, LOCDWORD( librender, i, XGRAPH ) ? 0 : LOCINT32( librender, i, ANGLE ), scalex, scaley, map ) ;
else
gr_blit( 0, ®ion, x, y, flags, map ) ;
if ( paletteid ) map->format->palette = palette;
if ( blendop ) map->blend_table = blend_table;
if ( map->modified ) map->modified = 0;
}
