Map initRoom() {
Map m = map_new();
unsigned short tileMap[] = {
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 0, 0, 0, 0, 2,
2, 0, 0, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2,
2, 1, 1, 1, 1, 1, 1, 1,
2, 1, 1, 1, 1, 1, 1, 1,
2, 1, 1, 2, 2, 1, 1, 2,
2, 1, 1, 2, 2, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 2, 1, 1, 2, 2
};
m = map_init(m,
"cage",
(mapVec){8, 8, 4},
tileMap,
3
);
Tile floorTile = tile_init(
tile_new(),
0
);
Tile wallTile = tile_init(
tile_new(),
3
);
map_add_tile(m, floorTile);
map_add_tile(m, wallTile);
return m;
}
int main (void)
{
PlayField *pf;
PlayField *spf;
PlayField *cpf;
Tile *tile;
g_type_init ();
pf = playfield_new ();
playfield_set_matrix_size (pf, 10, 7);
tile = tile_new (TILE_TYPE_ATOM);
playfield_set_tile (pf, 0, 0, tile);
playfield_set_tile (pf, 1, 0, tile);
playfield_set_tile (pf, 2, 0, tile);
playfield_set_tile (pf, 6, 3, tile);
g_object_unref (tile);
playfield_print (pf);
/* test copy */
g_message ("==== Copy Tests ====");
cpf = playfield_copy (pf);
playfield_print (cpf);
tile = tile_new (TILE_TYPE_WALL);
playfield_set_tile (pf, 3, 4, tile);
g_object_unref (tile);
playfield_print (pf);
playfield_print (cpf);
g_object_unref (cpf);
/* test swap */
g_message ("==== Swap Tests ====");
playfield_swap_tiles (pf, 2, 0, 0, 2);
playfield_print (pf);
/* test strip */
spf = playfield_strip (pf);
playfield_print (spf);
g_object_unref (spf);
g_object_unref (pf);
exit (0);
}
/** Create and place a new window with the given 'tag' and 'body'
* text, in the given 'col'umn
**/
static void
win_place(Tile *col, Text *tag, Text *body) {
Tile *win;
int max, min;
findplace(col, &min, &max);
win = tile_new(V, min, max, tagheight, col, tag, body);
list_add(col, win);
assert(ISWIN(win));
}
/* Find existing tile, make a new tile, or if we have a full set of tiles,
* reuse LRU.
*/
static Tile *
tile_find( Read *read, REGION *in, int x, int y )
{
Tile *tile;
int oldest;
GSList *p;
/* In cache already?
*/
if( (tile = tile_search( read, x, y )) ) {
tile_touch( tile );
return( tile );
}
/* Cache not full?
*/
if( read->max_tiles == -1 ||
read->ntiles < read->max_tiles ) {
if( !(tile = tile_new( read )) ||
tile_move( tile, x, y ) ||
tile_fill( tile, in ) )
return( NULL );
return( tile );
}
/* Reuse an old one.
*/
oldest = read->time;
tile = NULL;
for( p = read->cache; p; p = p->next ) {
Tile *t = (Tile *) p->data;
if( t->time < oldest ) {
oldest = t->time;
tile = t;
}
}
g_assert( tile );
#ifdef DEBUG
printf( "im_tile_cache: reusing tile %d x %d\n", tile->x, tile->y );
#endif /*DEBUG*/
if( tile_move( tile, x, y ) ||
tile_fill( tile, in ) )
return( NULL );
return( tile );
}
//Positionen und Größer immer bezogen auf scale
//FIXME check if area is already cached!
Render_State *render_state_new(Rect *area, Filter *f)
{
Render_State *state = calloc(sizeof(Render_State), 1);
Tile *tile;
if (area) {
tile = tile_new(area, tile_hash_calc(f, area), f, NULL, 1);
}
else
tile = NULL;
Render_Node *node = render_node_new(f, tile, state, 1);
node->need = 1000;
state->currstate = eina_array_new(64);
state->ready = eina_array_new(64);
eina_array_push(state->currstate, node);
return state;
}
//return 0 on success
Render_Node *render_state_getjob( Render_State *state)
{
int i;
Rect area;
Tilehash hash;
Render_Node *node;
Tile *tile;
Render_Node *jobnode;
int found;
struct timespec t_start;
struct timespec t_stop;
if (ea_count(state->ready))
return ea_pop(state->ready);
if (!ea_count(state->currstate)) {
if (state->pending) {
if (!ea_count(state->ready)) {
clock_gettime(CLOCK_MONOTONIC,&t_start);
lime_unlock();
while(state->pending && !ea_count(state->ready)) {
usleep(1000);
lime_lock();
lime_unlock();
}
lime_lock();
clock_gettime(CLOCK_MONOTONIC,&t_stop);
printf("we were blocked!\n");
global_stat_thread_blocked += t_stop.tv_sec - t_start.tv_sec
+ (t_stop.tv_nsec - t_start.tv_nsec)*1.0/1000000000.0;
}
assert(ea_count(state->ready));
return ea_pop(state->ready);
}
return NULL;
}
node = ea_data(state->currstate, ea_count(state->currstate)-1);
while (node) {
if (!end_of_iteration(node)) {
area.corner.x = node->pos.x;
area.corner.y = node->pos.y;
area.corner.scale = node->pos.scale;
area.width = node->tw;
area.height = node->th;
hash = tile_hash_calc(filter_get_input_filter(node->f, node->channel), &area);
if ((tile = cache_tile_get(&hash))) {
cache_stats_update(tile, 1, 0, 0, 0);
assert(node->mode);
//check if we're alredy waiting for this tile on another channel
found = 0;
if (tile->want)
for(i=0;i<ea_count(tile->want);i++)
if (node == ea_data(tile->want, i)) {
found = 1;
break;
}
if (found) {
//do nothing, we just continue
}
else if (!tile->channels) {
//tile is not yet rendered, push ref
if (!tile->want)
tile->want = eina_array_new(4);
node->need++;
ea_push(tile->want, node);
}
else {
if (node->mode == MODE_CLOBBER) {
//TODO attention: we assume channels are always processed in the same order
clobbertile_add(ea_data(node->inputs, node->channel), ea_data(tile->channels, node->channel));
assert(ea_count(node->inputs) > node->channel);
}
else if (node->mode == MODE_ITER) {
node->f->mode_iter->worker(node->f, ea_data(tile->channels, node->channel), node->channel, NULL, NULL, 0);
}
else
abort();
}
incnode(node);
}
//this node does not need any input tiles
else if (!ea_count(node->f_source_curr->node->con_ch_in)) {
jobnode = render_node_new(node->f_source_curr, tile_new(&area, hash, node->f_source_curr, node->f, node->depth), state, node->depth+1);
assert(jobnode->f->fixme_outcount);
cache_tile_add(jobnode->tile);
cache_stats_update(jobnode->tile, 0, 1, 0, 0);
//don't incnode so parent node will recheck for this tile
//the parent will propably be added to tile->need
return jobnode;
}
//node needs input tiles
else {
tile = tile_new(&area, hash, node->f_source_curr, node->f, node->depth);
cache_stats_update(tile, 0, 1, 0, 0);
if (node->f->fixme_outcount);
cache_tile_add(tile);
jobnode = render_node_new(node->f_source_curr, tile, state, node->depth+1);
tile->want = eina_array_new(4);
node->need++;
ea_push(tile->want, node);
//FIXME this incnode would cause problems with tiffsave!
//incnode(node);
node = jobnode;
//don't incnode so parent node will recheck for this tile
//the parent will propably be added to tile->need
ea_push(state->currstate, node);
//to lock it in the currstate array
node->need += 1000;
}
}
else {
//all inputs have been processed
//this doesn't mean that all inputs are available
jobnode = node;
node = ea_pop(state->currstate);
node->need -= 1000;
assert(node == jobnode);
if (jobnode->need) {
//what happens with jobnode?
//why this code??
if (ea_count(state->currstate))
node = ea_data(state->currstate, ea_count(state->currstate)-1);
else
node = NULL;
state->pending++;
}
else
return jobnode;
}
}
if (ea_count(state->ready))
return ea_pop(state->ready);
if (state->pending) {
lime_unlock();
while(state->pending && !ea_count(state->ready)) {
usleep(1000);
lime_lock();
lime_unlock();
}
lime_lock();
assert(ea_count(state->ready));
return ea_pop(state->ready);
}
return NULL;
}
/* Find existing tile, make a new tile, or if we have a full set of tiles,
* reuse LRU.
*/
static Tile *
tile_find( VipsTileCache *cache, VipsRegion *in, int x, int y )
{
Tile *tile;
int oldest, topmost;
GSList *p;
/* In cache already?
*/
if( (tile = tile_search( cache, x, y )) ) {
tile_touch( tile );
return( tile );
}
/* VipsTileCache not full?
*/
if( cache->max_tiles == -1 ||
cache->ntiles < cache->max_tiles ) {
if( !(tile = tile_new( cache )) ||
tile_move( tile, x, y ) ||
tile_fill( tile, in ) )
return( NULL );
return( tile );
}
/* Reuse an old one.
*/
switch( cache->strategy ) {
case VIPS_CACHE_RANDOM:
oldest = cache->time;
tile = NULL;
for( p = cache->tiles; p; p = p->next ) {
Tile *t = (Tile *) p->data;
if( t->time < oldest ) {
oldest = t->time;
tile = t;
}
}
break;
case VIPS_CACHE_SEQUENTIAL:
topmost = cache->in->Ysize;
tile = NULL;
for( p = cache->tiles; p; p = p->next ) {
Tile *t = (Tile *) p->data;
if( t->y < topmost ) {
topmost = t->y;
tile = t;
}
}
break;
default:
g_assert( 0 );
}
g_assert( tile );
VIPS_DEBUG_MSG( "tilecache: reusing tile %d x %d\n", tile->x, tile->y );
if( tile_move( tile, x, y ) ||
tile_fill( tile, in ) )
return( NULL );
return( tile );
}
tile_t*
setup_text_tile (const cairo_font_options_t* font_opts,
gdouble dpi,
gint w,
gint h)
{
tile_t* tile = NULL;
cairo_status_t status;
cairo_surface_t* surface = NULL;
cairo_surface_t* text = NULL;
cairo_surface_t* shadow = NULL;
cairo_t* cr;
gdouble width = (gdouble) w;
gdouble height = (gdouble) h;
raico_blur_t* blur = NULL;
cairo_pattern_t* pattern = NULL;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
status = cairo_surface_status (surface);
if (status != CAIRO_STATUS_SUCCESS)
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
cr = cairo_create (surface);
status = cairo_status (cr);
if (status != CAIRO_STATUS_SUCCESS)
{
cairo_surface_destroy (surface);
g_print ("Error: \"%s\"\n", cairo_status_to_string (status));
}
// clear and render drop-shadow and bubble-background
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
text = render_text_to_surface (
"After an evening of hacking at the"
" Fataga hotel here at GUADEC I "
"can present you even text-scroll "
"with blur-cache and fade-out mask"
" and I dedicate this to Behdad who"
" sadly burst his upper lip during "
"the evening and had to go to the "
"hospital. Some spanish KDE-folks "
"kindly accompanied him to help out"
" with translation. True collaboration!\0",
width,
height,
font_opts,
dpi);
shadow = render_text_to_surface (
"After an evening of hacking at the"
" Fataga hotel here at GUADEC I "
"can present you even text-scroll "
"with blur-cache and fade-out mask"
" and I dedicate this to Behdad who"
" sadly burst his upper lip during "
"the evening and had to go to the "
"hospital. Some spanish KDE-folks "
"kindly accompanied him to help out"
" with translation. True collaboration!\0",
width,
height,
font_opts,
dpi);
// create and setup blur
blur = raico_blur_create (RAICO_BLUR_QUALITY_LOW);
raico_blur_set_radius (blur, 4);
// now blur it
raico_blur_apply (blur, shadow);
// blur no longer needed
raico_blur_destroy (blur);
cairo_push_group (cr);
cairo_set_source_surface (cr,
shadow,
0.0f,
0.0f);
cairo_paint (cr);
pattern = cairo_pop_group (cr);
cairo_set_source_rgba (cr, 0.0f, 0.0f, 0.0f, 1.0f);
cairo_mask (cr, pattern);
cairo_surface_destroy (shadow);
cairo_pattern_destroy (pattern);
cairo_set_source_surface (cr, text, 0.0f, 0.0f);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (text);
tile = tile_new (surface, 6);
cairo_surface_destroy (surface);
return tile;
}
