animation.c

   1
   2 /**
   3  *
   4  * Tennix! SDL Port
   5  * Copyright (C) 2003, 2007, 2008, 2009 Thomas Perl <thp@thpinfo.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20  * MA  02110-1301, USA.
  21  *
  22  **/
  23
  24
  25 #include <stdlib.h>
  26 #include <assert.h>
  27
  28 #include "tennix.h"
  29 #include "graphics.h"
  30 #include "animation.h"
  31
  32 #include "credits.h"
  33
  34 Animation* animation_new()
  35 {
  36     Animation* animation = (Animation*)calloc(1, sizeof(Animation));
  37     assert(animation != NULL);
  38     return animation;
  39 }
  40
  41 Animation* animation_append(Animation* animation, AnimationPart* part)
  42 {
  43     if (part->end > animation->duration) {
  44         animation->duration = part->end;
  45     }
  46
  47     if (animation->head == NULL) {
  48         /* insert into empty list */
  49         part->next = NULL;
  50         part->prev = NULL;
  51         animation->head = part;
  52         animation->tail = part;
  53     } else {
  54         /* insert into non-empty list */
  55         part->prev = animation->tail;
  56         part->next = NULL;
  57         animation->tail->next = part;
  58         animation->tail = part;
  59     }
  60
  61     return animation;
  62 }
  63
  64 void animation_free(Animation* animation)
  65 {
  66     AnimationPart* part;
  67     AnimationPart* next;
  68
  69     part = animation->head;
  70     while (part != NULL) {
  71         next = part->next;
  72         animation_part_free(part);
  73         part = next;
  74     }
  75
  76     free(animation);
  77 }
  78
  79 AnimationState* animation_state_new(Animation* animation)
  80 {
  81     AnimationState* state = (AnimationState*)calloc(1, sizeof(AnimationState));
  82     assert(state != NULL);
  83
  84     state->animation = animation;
  85     state->started = SDL_GetTicks();
  86     state->ending = state->started + animation->duration;
  87
  88     return state;
  89 }
  90
  91 void animation_state_run(AnimationState* state, int interruptible)
  92 {
  93     AnimationPart* p;
  94     SDL_Event e;
  95
  96     clear_screen();
  97     store_screen();
  98     while (animation_state_update(state)) {
  99         if (interruptible) {
 100             while (SDL_PollEvent(&e)) {
 101                 if (e.type == SDL_KEYDOWN || e.type == SDL_QUIT) {
 102                     return;
 103                 }
 104             }
 105         }
 106         p = state->animation->head;
 107         while (p != NULL) {
 108             animation_part_display(p, state);
 109             p = p->next;
 110         }
 111         updatescr();
 112     }
 113 }
 114
 115 int animation_state_update(AnimationState* state)
 116 {
 117     assert(state != NULL);
 118
 119     state->current = SDL_GetTicks();
 120
 121     return state->current < state->ending;
 122 }
 123
 124 void animation_state_free(AnimationState* state)
 125 {
 126     free(state);
 127 }
 128
 129 AnimationPart* animation_part_new_from_surface(Uint32 start, Uint32 end,
 130         unsigned int effects, int x, int y, int zindex, unsigned int gravity,
 131         SDL_Surface* surface, unsigned char free_surface, int pos, int count)
 132 {
 133     AnimationPart* part = (AnimationPart*)calloc(1, sizeof(AnimationPart));
 134     assert(part != NULL);
 135
 136     part->start = start;
 137     part->end = end;
 138     part->effects = effects;
 139
 140     part->x = x;
 141     part->y = y;
 142     part->zindex = zindex;
 143
 144     part->gravity = gravity;
 145
 146     part->surface = surface;
 147     part->free_surface = free_surface;
 148     part->pos = pos;
 149     part->count = count;
 150
 151     return part;
 152 }
 153
 154 AnimationPart* animation_part_new_text(Uint32 start, Uint32 end,
 155         unsigned int effects, int x, int y, int zindex, unsigned int gravity,
 156         font_id id, const char* text, Uint8 r, Uint8 g, Uint8 b)
 157 {
 158     return animation_part_new_from_surface(
 159             start,
 160             end,
 161             effects,
 162             x,
 163             y,
 164             zindex,
 165             gravity,
 166             font_render_surface(id, text, r, g, b),
 167             1,
 168             0,
 169             1
 170     );
 171 }
 172
 173 void animation_part_display(AnimationPart* part, AnimationState* state)
 174 {
 175     Uint32 start = state->started + part->start;
 176     Uint32 end = state->started + part->end;
 177     Uint32 x, y;
 178     float p;
 179     SDL_Surface* surface;
 180
 181     if (state->current < start || state->current > end) {
 182         /* this part has had it's time (or is yet to have it ;) */
 183         return;
 184     }
 185
 186     surface = part->surface;
 187     p = (float)(state->current - start)/(float)(end - start);
 188
 189     if (part->effects & ANIMATION_ZOOM_2X) {
 190         surface = rotozoom_surface(surface, 0.0, p+1);
 191     }
 192
 193     switch (part->gravity) {
 194         case GRAVITY_CENTER_UPPERHALF:
 195             x = (WIDTH - surface->w)/2 + part->x;
 196             y = HEIGHT/2 - surface->h + part->y;
 197             break;
 198         case GRAVITY_CENTER_BOTTOMHALF:
 199             x = (WIDTH - surface->w)/2 + part->x;
 200             y = HEIGHT/2 + part->y;
 201             break;
 202         case GRAVITY_CENTER_SCREEN:
 203             x = (WIDTH - surface->w)/2 + part->x;
 204             y = (HEIGHT - surface->h)/2 + part->y;
 205             break;
 206         case GRAVITY_TOP:
 207             x = (WIDTH - surface->w)/2 + part->x;
 208             y = part->y;
 209             break;
 210         case GRAVITY_TOPLEFT:
 211             /* fall-through to default */
 212         default:
 213             x = part->x;
 214             y = part->y;
 215             break;
 216     }
 217
 218     if (part->effects & ANIMATION_FROM_BOTTOM) {
 219         y = y * p + (HEIGHT-part->surface->h) * (1-p);
 220     }
 221
 222     if (part->effects & ANIMATION_SLIDE_LEFT) {
 223         x = x * p;
 224     }
 225
 226     if (part->effects & ANIMATION_SLIDE_RIGHT) {
 227         x = (WIDTH-surface->w) * (1.-p) + x * p;
 228     }
 229
 230     blit_surface_simple(surface, x, y);
 231
 232     /* FIXME: fade in and out should be handled by blitting w/ alpha value */
 233     if (part->effects & ANIMATION_FADE_IN) {
 234         if (p < ANIMATION_FADE_PART) {
 235             rectangle_alpha(x, y, surface->w, surface->h, 0, 0, 0,
 236                 255*(1-(1./ANIMATION_FADE_PART)*p));
 237         }
 238     }
 239
 240     if (part->effects & ANIMATION_FADE_OUT) {
 241         if (p > (1-ANIMATION_FADE_PART)) {
 242             rectangle_alpha(x, y, surface->w, surface->h, 0, 0, 0,
 243                 255*((1./ANIMATION_FADE_PART)*(p-(1-ANIMATION_FADE_PART))));
 244         }
 245     }
 246
 247     if (part->effects & ANIMATION_ZOOM_2X) {
 248         SDL_FreeSurface(surface);
 249     }
 250 }
 251
 252 void animation_part_free(AnimationPart* part)
 253 {
 254     /* free surface if necessary */
 255     if (part->free_surface) {
 256         SDL_FreeSurface(part->surface);
 257     }
 258
 259     free(part);
 260 }
 261
 262
 263 Animation* create_intro()
 264 {
 265     Animation* intro = animation_new();
 266
 267     /* Just some weird demo of how the animations work */
 268     animation_append(intro, animation_part_new_text(100, 4000, ANIMATION_FADE_IN | ANIMATION_FADE_OUT, 0, 0, 0, GRAVITY_CENTER_SCREEN, FONT_MEDIUM, "thpinfo.com presents", 255, 255, 255));
 269     animation_append(intro, animation_part_new_from_surface(4000, 8000, ANIMATION_FADE_IN | ANIMATION_FADE_OUT | ANIMATION_ZOOM_2X, 0, 0, 0, GRAVITY_CENTER_SCREEN, get_surface(GR_TENNIXLOGO), 0, 0, 1));
 270
 271     return intro;
 272 }
 273
 274 Animation* create_credits()
 275 {
 276     int pos = 0;
 277     Animation* credits = animation_new();
 278     while (credits_text[pos] != NULL) {
 279         animation_append(credits,
 280                 animation_part_new_text(100+pos*CREDITS_OFFSET,
 281                     100+pos*CREDITS_OFFSET + CREDITS_DURATION,
 282                     ANIMATION_FADE_IN | ANIMATION_FADE_OUT | ANIMATION_FROM_BOTTOM,
 283                     0, 0, 0,
 284                     GRAVITY_TOP,
 285                     FONT_MEDIUM,
 286                     credits_text[pos],
 287                     255, 255, 255));
 288         pos++;
 289     }
 290     return credits;
 291 }
 292