time-critical-procs.cc

Go to the documentation of this file.

// Copyright 2004, 2005 Maurizio Colucci.
//
// This file is part of FACK. 
// 
// FACK 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; either version 2 of the License, or
// (at your option) any later version.
//
// FACK 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 Foobar; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#include "fack.hpp" 



void
write_pixel_with_src_alpha( 
    cfsurf & dest 
    , int x
    , int y
    , rgbaf pixel)
{
    // BEGIN decl
    rgbaf bg_pixel;
    float inverse_alpha,  final_r, final_g, final_b, bg_r, bg_b, bg_g;
    // END


    // BEGIN precond
    assert (y<dest.apparent_ht);
    assert (x<dest.apparent_wt);
    //assert(pixel.a <= 1.0f); // \todo assert fails sometimes, probably due to numerical problems
    assert(pixel.r <= 255.0f);
    assert(pixel.g <= 255.0f);
    assert(pixel.b <= 255.0f);
    // END
    if (pixel.a < 0.0000000001f /* completely transparent */)
    {}
    else if (pixel.a > 0.999999999f /* opaque */){
        dest.set_pixel(  x,  y , pixel);
    }
    else{
        bg_pixel = dest.get_pixel( x, y);
        //assert(bg_pixel.a == 255.0f);
        //assert(pixel.a <= 1.0f);
        //alpha = pixel.a / 255.0f; // @@ optimization: remove this
        // division: make layers keep alpha
        // values already scaled.
        inverse_alpha = 1.0f - pixel.a;
        bg_r = bg_pixel.r;
        bg_g = bg_pixel.g;
        bg_b = bg_pixel.b;

        // @@ optimize by taking a rgbaf as input 
        final_r = inverse_alpha *  bg_r + pixel.a * pixel.r;
        final_g = inverse_alpha *  bg_g + pixel.a * pixel.g;
        final_b = inverse_alpha *  bg_b + pixel.a * pixel.b;

        dest.set_pixel(  x,  y , rgbaf( final_r, final_g, final_b, 1.0f));

    }
}


void 
blit_char( 
    const anim_frame_and_pos & src,
    float scaling ,
    float lighting,
    cfsurf & screen )
{
    // BEGIN decl
    int new_wt, new_ht;
    float old_wt_div_new_wt, old_ht_div_new_ht;
    int x, y; 
    int hot_x_scaled, hot_y_scaled, x_final_offset, y_final_offset;
    float srcx, srcy;
    rgbaf pixel; int destx, desty;
    // END

    // BEGIN precond
    assert(scaling > 0.0f);
    //     assert(screen.apparent_wt == screen.real_wt); // @@ why does this fail?
    //     assert(screen.apparent_ht == screen.real_ht);
    // END

    new_wt = int(float( src.surf->w) * scaling);
    new_ht = int(float( src.surf->h) * scaling);

    if (new_ht == src.surf->h || new_wt == src.surf->w)
    {
        // use different algo to prevent fuzzy image. It is also
        // faster.

        new_ht = src.surf->h;
        new_wt = src.surf->w;
            
        hot_x_scaled  = src.surf->hot_spot.x;
        hot_y_scaled  = src.surf->hot_spot.y;

        x_final_offset = src.position_x - hot_x_scaled;
        y_final_offset = src.position_y - hot_y_scaled;

        // @@ Optimization: move the clipping condition out of the loop.
        for (x = 0 ; x< new_wt; x++)
        {
            for (y = 0 ; y< new_ht ; y++)
            {
                pixel = mul_scalar_rgbaf_noalpha(lighting, src.surf->get_pixel( x, y));
                destx = x + x_final_offset;
                desty = y + y_final_offset;

                if (  destx >= screen.offs_x && destx < screen.offs_x + screen.real_wt
                      && 
                      desty>=screen.offs_y && desty < screen.offs_y + screen.real_ht)
                {
                    write_pixel_with_src_alpha(screen, destx, desty , pixel);
                }
            }
        }

    }
    else
    {
        hot_x_scaled  = int(float(src.surf->hot_spot.x) * scaling);
        hot_y_scaled  = int(float(src.surf->hot_spot.y) * scaling);

        x_final_offset = src.position_x - hot_x_scaled;
        y_final_offset = src.position_y - hot_y_scaled;

        old_wt_div_new_wt = (float)src.surf->w / new_wt; // @@ dangerous if they are very close?
        old_ht_div_new_ht = (float)src.surf->h / new_ht;

        // @@ Optimization: move the clipping condition out of the loop.
        for (x = 0 ; x< new_wt; x++)
        {
            for (y = 0 ; y< new_ht ; y++)
            {
                srcx = float(x) * old_wt_div_new_wt;
                srcy = float(y) * old_ht_div_new_ht;
                        
                pixel = mul_scalar_rgbaf_noalpha(lighting, 
                                                 src.surf->get_pixel_with_interpolation( srcx, srcy));
                destx = x + x_final_offset;
                desty = y + y_final_offset;

                if (  destx >= screen.offs_x && destx < screen.offs_x + screen.real_wt
                      && 
                      desty>=screen.offs_y && desty < screen.offs_y + screen.real_ht)
                {
                    write_pixel_with_src_alpha(screen, destx, desty , pixel);
                }
            }
        }
    }
}

inline
pt<cfsurf> 
sum_each_pixel( 
    const list<surf_and_weight > & surfs, 
    float time,
    SDL_Rect visible_rect)
{
    //BEGIN decl.
    rgbaf dest_color;
    pt<cfsurf> merged_surf;
    int  wt, ht, x, y, offs_x, offs_y, max_x, max_y;
    surf_and_weight first_surf;
    list<surf_and_weight > ::const_iterator l;
    float a;
    double cosine;
    map<surf_and_weight, double> oscillation_of;
    list<int> offs_xs, offs_ys, max_xs, max_ys;
    int left_bound, right_bound, top_bound, bottom_bound;
    // END

    first_surf = surfs.front();

    // BEGIN precond
    assert(surfs.size() > 0);
    foreach(l, surfs){
        assert ( l->surf->apparent_wt == first_surf.surf->apparent_wt);
        assert ( l->surf->apparent_ht == first_surf.surf->apparent_ht);
    }
    // END

    setof_( l->surf->offs_x, l, surfs, true, offs_xs);
    setof_( l->surf->offs_y, l, surfs, true, offs_ys);

    offs_x = min(offs_xs);
    offs_y = min(offs_ys);

    setof_( l->surf->offs_x + l->surf->real_wt, l, surfs, true, max_xs);
    setof_( l->surf->offs_y + l->surf->real_ht, l, surfs, true, max_ys);

    max_x = max(max_xs);
    max_y = max(max_ys);

    wt = max_x - offs_x;
    ht = max_y - offs_y;

    merged_surf = NEW( cfsurf(first_surf.surf->apparent_wt
                           , first_surf.surf->apparent_ht
                           , wt
                           , ht
                           , offs_x
                           , offs_y));


    // BEGIN fill the map "oscillation_of"
    foreach(l, surfs){
        a = l->oscillation_amplitude;
        assert (0.0f <= a && a< 0.5f);
        cosine = cos(l->oscillation_speed * time); 
        oscillation_of[*l] =  a  * pow(cosine,3) + 1.0f - a ; 
    }
    // END


    left_bound = std::max(offs_x, int(visible_rect.x));
    top_bound = std::max(offs_y, int(visible_rect.y));
    bottom_bound = std::min(offs_y + ht, int(visible_rect.y + visible_rect.h));
    right_bound = std::min(offs_x + wt, int(visible_rect.x + visible_rect.w));

    for ( x = left_bound; x < right_bound; x++)
    {
        for ( y = top_bound; y < bottom_bound; y++)
        {
            dest_color = rgbaf(0,0,0,0);

            foreach(l, surfs){  

                dest_color = sum_rgbaf ( 
                    dest_color ,
                    mul_scalar_rgbaf(
                        l->calc_weight(int_pair(x, y)),
                        mul_scalar_rgbaf_noalpha(
                            map_get(oscillation_of, *l),
                            l->surf->get_pixel( x, y))));
            }
            merged_surf->set_pixel( x, y, dest_color);
        }
    } 
    return merged_surf;
}
        




void
cfsurf::blit_with_src_alpha(
    cfsurf & dest)const
{
    // BEGIN decl.
    int x, y;
    rgbaf pixel;
    // END

    assert(apparent_ht == dest.apparent_ht);
    assert(apparent_wt == dest.apparent_wt);

    for(x = offs_x ; x< offs_x + real_wt ; x++){
        for(y = offs_y ; y< offs_y + real_ht ; y++){
            pixel = this->get_pixel( x, y);
            write_pixel_with_src_alpha(dest, x, y, pixel);
        }
    }
}



pt<layer_lit> 
FACK::lit_layer_of_unlit_layer ( 
    const layer_unlit_after_anim & unlit,
    const set<pt<light> > & on_lights,
    float time,
    SDL_Rect visible_rect)const
{
    // BEGIN decl.
    float sum;
    set<pt<light> >::const_iterator l;
    map<pt<light>, float> normalized_weight_of_light;
    list<layer_unlit_after_anim >::const_iterator obj_unlit;
    pt<cfsurf> surf;
    list<surf_and_weight > on_surfs;
    list<surf_with_name>::const_iterator v;
    bool exists_a_layer_which_represents_that_light;
    // END

    // BEGIN precond
    assert(on_lights.size() > 0);
    assert(unlit.lit_versions.size() >0);
    
    foreach(l, on_lights){

        exists_a_layer_which_represents_that_light = false;

        foreach(v, unlit.lit_versions){
            if(v->ligh == *l )
            {
                exists_a_layer_which_represents_that_light = true;
            }
        }
        assert(exists_a_layer_which_represents_that_light);
    }
    // END

    // BEGIN compute normalized_weight_of_light

    sum = 0.0f;
    foreach(l, on_lights){
        sum += (*l)->weight;}

    foreach(l, on_lights){
        normalized_weight_of_light[*l] = (*l)->weight / sum;}
    // END

    setof_ (  surf_and_weight(
                  v->surf, 
                  map_get(normalized_weight_of_light, v->ligh), 
                  v->ligh->oscillation_amplitude, 
                  v->ligh->oscillation_speed,
                  circle_of_light(v->ligh)), 
        v,
        unlit.lit_versions,
        in(v->ligh, on_lights),
        on_surfs);
    
    assert(on_surfs.size() >0);

    surf = sum_each_pixel( on_surfs, time, visible_rect);
    return NEW(layer_lit( surf, unlit.y_walkbehind));
}


void
cfsurf::opaque_blit_to_sdl_surface(
    SDL_Surface * screen,
    SDL_Rect src_rect_to_blit /* this rect will be blitted at 0,0 on the screen */ )const
{
    // BEGIN decl
    int src_x, src_y;
    int dst_x, dst_y;
    rgbaf pix;
    Uint32* ptr;
    // END

    // BEGIN precond
    assert(screen->format->BytesPerPixel == 4);

    assert(src_rect_to_blit.x >=0);
    assert(src_rect_to_blit.x < this->apparent_wt);

    assert(src_rect_to_blit.x + src_rect_to_blit.w >= 0);
    assert(src_rect_to_blit.x + src_rect_to_blit.w <= /* sic*/ this->apparent_wt);

    assert(src_rect_to_blit.y >=0);
    assert(src_rect_to_blit.y < this->apparent_ht);

    assert(src_rect_to_blit.y + src_rect_to_blit.h >= 0);
    assert(src_rect_to_blit.y + src_rect_to_blit.h <= /*sic */this->apparent_ht);
    // END

    SDL_LockSurface(screen);

    // I removed the optimiz:
    // 
    // for (x = offs_x; x < offs_x + real_wt; x++)
    //
    // it is useless because this proc is only used to blit the final
    // surface to the screen.  Furthermore, with that optimization it
    // was silly to call get_pixel, because it has an if inside.


    for (src_x = src_rect_to_blit.x, dst_x = 0;
         src_x < src_rect_to_blit.x + src_rect_to_blit.w; 
         src_x++, dst_x ++)
    {
        for (src_y = src_rect_to_blit.y, dst_y = 0;
             src_y < src_rect_to_blit.y + src_rect_to_blit.h;
             src_y++, dst_y ++)
        {
            pix = this->get_pixel( src_x, src_y); 

            ptr = (Uint32 *) (screen->pixels) + dst_x + dst_y * screen->w;

            * ptr = SDL_MapRGB(screen->format
                , Uint8(pix.r)
                , Uint8(pix.g)
                , Uint8(pix.b));
        }
    }
    SDL_UnlockSurface(screen);
}



  

---