src/SDLAnimation/SDLAnimation.cpp

   1 // Copyright 2008 Brian Caine
   2
   3 // This file is part of Potpourri.
   4
   5 // Potpourri is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9
  10 // Potpourri is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTIBILITY of FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with Potpourri. If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // NOTES:
  20 // uhh, sauce?
  21
  22 #include "SDLAnimation.h"
  23 #include "../SDLPlugin/SDLSurface.h"
  24
  25 #include "../../include/core/common.h"
  26 #include "../../include/core/Actor.h"
  27
  28 #include <SDL/SDL_rotozoom.h>
  29
  30 using namespace fragrant;
  31
  32 SDLAnimation::SDLAnimation(SDLAnimationData ndata)
  33 {
  34   data = ndata;
  35   cur_frame = -1;
  36   time = -1;
  37 }
  38
  39 SDLAnimation::~SDLAnimation()
  40 {
  41   this->destroy();
  42 }
  43
  44 GraphicsPair makePair(int x, int y)
  45 {
  46   GraphicsPair results;
  47   results.x = x;
  48   results.y = y;
  49
  50   return results;
  51 }
  52
  53 GraphicsPair rotate_point(GraphicsPair src, float angle)
  54 {
  55   src.y = -src.y;
  56
  57   float radius = sqrt(pow(src.x, 2) + pow(src.y, 2));
  58   float nangle = (radius > 0) ? fromRadians(acos(src.x / radius)) : 0;
  59
  60   if (src.x == 0 && src.y == 0)
  61     return src;
  62
  63   if (angle == 0)
  64     return makePair(src.x, -src.y);
  65
  66   while (angle < 0)
  67     angle += 360;
  68   angle = static_cast<int>(angle) % 360;
  69
  70   angle += nangle;
  71
  72   GraphicsPair results = makePair(
  73     static_cast<int>(radius * cos(toRadians(angle))),
  74     -static_cast<int>(radius * sin(toRadians(angle))));
  75
  76   return results;
  77 }
  78
  79 void SDLAnimation::draw(Target* target, GraphicsRect* destrect,
  80                         GraphicsPair* srcrect, float angle)
  81 {
  82   if (cur_frame == -1 && time == -1)
  83     {
  84       cur_frame = 0;
  85       time = SDL_GetTicks();
  86       ticks_left = 0;
  87     }
  88
  89   else
  90     {
  91       int ntime = SDL_GetTicks();
  92       ticks_left -= (ntime - time);
  93       time = ntime;
  94
  95       while (ticks_left <= 0)
  96         {
  97           cur_frame++;
  98           cur_frame %= data.frames.size();
  99
 100           ticks_left = data.frames.at(cur_frame).y + ticks_left;
 101         }
 102     }
 103
 104   SDLSurface* target_surf = dynamic_cast<SDLSurface*>(target);
 105
 106   // sometime later make this more efficient
 107
 108   SDLAnimationFrame current_frame_data = data.images.at(cur_frame);
 109   SDL_Surface* rotated_image = (angle == 0.0) ?
 110     (current_frame_data.image) :
 111     (rotozoomSurface(current_frame_data.image, angle, 1, SMOOTH));
 112   SDL_Surface* dest_surf = target_surf->surf;
 113   bool free_me = rotated_image != current_frame_data.image;
 114
 115   SDL_Rect destrect_sdl = {0, 0, 0, 0};
 116   SDL_Rect srcrect_sdl = {0, 0, rotated_image->w, rotated_image->h};
 117
 118   Pair<float> offset = getOffset(
 119     makePair(current_frame_data.image->w,current_frame_data.image->h), angle);
 120   GraphicsPair sub_offset = rotate_point(
 121     ::makePair(static_cast<int>(current_frame_data.offset.x),
 122                static_cast<int>(current_frame_data.offset.y)), angle);
 123
 124   if (destrect)
 125     {
 126       destrect_sdl.x = destrect->xy.x + offset.x + sub_offset.x;
 127       destrect_sdl.y = destrect->xy.y + offset.y + sub_offset.y;
 128     }
 129
 130   SDL_BlitSurface(rotated_image, &srcrect_sdl, dest_surf, &destrect_sdl);
 131
 132   if (srcrect)
 133     {
 134       srcrect->x = srcrect_sdl.x;
 135       srcrect->y = srcrect_sdl.y;
 136     }
 137
 138   if (free_me)
 139     SDL_FreeSurface(rotated_image);
 140
 141   return;
 142 }
 143
 144 void SDLAnimation::destroy()
 145 {
 146   int cur;
 147   for (cur = 0; cur < data.images.size(); cur++)
 148     SDL_FreeSurface(data.images.at(cur).image);
 149
 150   for (cur = 0; cur < data.root_surfaces.size(); cur++)
 151     SDL_FreeSurface(data.root_surfaces.at(cur));
 152
 153   return;
 154 }