src/Sprite.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 // NOTES:
  19
  20 // See Sprite.h
  21
  22 #include <iostream>
  23 #include <cmath>
  24
  25 #include <SDL/SDL_rotozoom.h>
  26
  27 #include "Sprite.h"
  28
  29 #define PI 3.141592653589793
  30
  31 using namespace fragrant;
  32
  33 Sprite* Sprite::makeSprite(std::vector<SDL_Surface*> dframes,
  34                            SpriteParams dparams)
  35 {
  36   Sprite* the_sprite = new Sprite(dframes, dparams);
  37
  38   if (!was_made)
  39     {
  40       delete the_sprite;
  41       the_sprite = 0;
  42       std::cerr << "Sprite::makeSprite(): Error making sprite" << std::endl;
  43     }
  44
  45   was_made = false;
  46
  47   return the_sprite;
  48 }
  49
  50 Sprite::~Sprite()
  51 {
  52   std::map<int, std::vector<SDL_Surface*> >::iterator biter;
  53   std::vector<SDL_Surface*>::iterator niter;
  54
  55   for (biter = angle_frames.begin(); biter != angle_frames.end(); biter++)
  56     for (niter = biter->second.begin(); niter != biter->second.end(); niter++)
  57       {
  58         SDL_FreeSurface(*niter);
  59       }
  60 }
  61
  62 void Sprite::draw(SDL_Surface* dest)
  63 {
  64   // timing stuff
  65
  66   int cur_ticks = SDL_GetTicks();
  67   ticks_left -= (cur_ticks - last_tick);
  68
  69   last_tick = cur_ticks;
  70
  71   while (ticks_left <= 0)
  72     {
  73       cur_frame++;
  74       if (cur_frame == frames.size() && sequence.repeat)
  75         cur_frame = 0;
  76
  77       ticks_left = sequence.frames.at(cur_frame).duration + ticks_left;
  78     }
  79
  80   // rotation stuff
  81   std::map<int, std::vector<SDL_Surface*> >::iterator iter;
  82
  83   std::vector<SDL_Surface*> cocked_frames;
  84
  85   for (iter = angle_frames.begin(); iter != angle_frames.end(); iter++)
  86     {
  87       if ((sequence.angle + ANGLE_SNAP > iter->first) &&
  88           (sequence.angle - ANGLE_SNAP < iter->first))
  89         cocked_frames = iter->second;
  90     }
  91
  92   if (!cocked_frames.size())
  93     {
  94       makeNewAngleFrame(sequence.angle);
  95       cocked_frames = angle_frames[sequence.angle];
  96     }
  97
  98   // actual rendering
  99
 100   SDL_Surface* surface = cocked_frames.at(cur_frame);
 101
 102   SDL_Rect pos = {sequence.position.at(0) + angle_offset.at(0),
 103                   sequence.position.at(1) + angle_offset.at(1),
 104                   surface->w, surface->h};
 105   SDL_BlitSurface(surface, 0, dest, &pos);
 106
 107   return;
 108 }
 109
 110 Sprite::Sprite(std::vector<SDL_Surface*> dframes, SpriteParams dparams)
 111 {
 112   was_made = true;
 113
 114   if (!dframes.size() || !dparams.frames.size())
 115     was_made = false;
 116
 117   std::vector<Frame>::iterator iter;
 118   for (iter = dparams.frames.begin(); iter != dparams.frames.end(); iter++)
 119     if (iter->frame >= dframes.size())
 120       was_made = false;
 121
 122   if ((dparams.position.size() < 2) || (dparams.focal_point.size() < 2))
 123     was_made = false;
 124
 125   if (dparams.position.size() > 2)
 126     std::cerr << "Sprite::makeSprite(): Warning, More position "
 127               << "parameters then needed..." << std::endl;
 128
 129   if (dparams.focal_point.size() > 2)
 130     std::cerr << "Sprite::makeSprite(): Warning, More focal point "
 131               << "parameters then needed..." << std::endl;
 132
 133   if (dparams.angle > 360)
 134     {
 135       std::cerr << "Sprite::makeSprite(): Warning, Angle is greater than 360, "
 136                 << "wrapping around..." << std::endl;
 137       dparams.angle %= 360;
 138     }
 139
 140   if (was_made)
 141     {
 142       sequence = dparams;
 143       frames = dframes;
 144
 145       cur_frame = 0;
 146       last_tick = -1;
 147       ticks_left = -1;
 148
 149       makeAngleFrames();
 150       calcAngleOffset();
 151     }
 152 }
 153
 154 bool Sprite::makeAngleFrames()
 155 {
 156   int cur;
 157
 158   for (cur = 0; cur < CIRCLE; cur += ANGLE_CACHE)
 159     makeNewAngleFrame(cur);
 160
 161   return true;
 162 }
 163
 164 void Sprite::makeNewAngleFrame(int angle)
 165 {
 166   SDL_Surface* temp;
 167
 168   std::vector<SDL_Surface*> new_frames;
 169
 170   std::vector<SDL_Surface*>::iterator iter;
 171
 172   for (iter = frames.begin(); iter != frames.end(); iter++)
 173     {
 174       temp = rotozoomSurface(*iter, static_cast<double>(angle), 1, 1);
 175       new_frames.push_back(temp);
 176     }
 177
 178   angle_frames[angle] = new_frames;
 179
 180   return;
 181 }
 182
 183 void Sprite::calcAngleOffset()
 184 {
 185   std::vector<int> new_offset;
 186
 187   int rot = -1;
 188   SDL_Surface* temp_surf = 0;
 189
 190   std::map<int, std::vector<SDL_Surface*> >::iterator iter;
 191   for (iter = angle_frames.begin(); iter != angle_frames.end(); iter++)
 192     if ((sequence.angle + ANGLE_SNAP > iter->first) &&
 193         (sequence.angle - ANGLE_SNAP < iter->first))
 194       {
 195         rot = iter->first;
 196         temp_surf = iter->second.at(0);
 197       }
 198
 199   if (!temp_surf)
 200     return;
 201
 202   float x_1, y_1, x_2, y_2, radius, theta_1, theta_2;
 203   float w_1, h_1, w_2, h_2;
 204
 205   x_1 = sequence.focal_point.at(0);
 206   y_1 = sequence.focal_point.at(1);
 207
 208   w_1 = frames.at(0)->w;
 209   h_1 = frames.at(0)->h;
 210
 211   radius = static_cast<int>(sqrt(
 212     pow((static_cast<double>(x_1), static_cast<double>(w_1) / 2), 2) +
 213     pow((static_cast<double>(y_1), static_cast<double>(h_1) / 2), 2) ));
 214
 215   theta_1 = (180 / PI) * acos(static_cast<double>(x_1) /
 216     static_cast<double>(radius));
 217   theta_2 = theta_1 + rot;
 218
 219   x_2 = radius * cos(theta_2 * (PI / 180)) + (w_1 / 2);
 220   y_2 = radius * sin(theta_2 * (PI / 180)) + (h_1 / 2);
 221
 222   w_2 = temp_surf->w;
 223   h_2 = temp_surf->h;
 224
 225   new_offset.push_back(static_cast<int>(
 226     (x_2 - x_1) + ((w_1 / 2) - (w_2 / 2))));
 227   new_offset.push_back(static_cast<int>(
 228     (y_2, - y_1) + ((h_1 / 2) - (h_2 / 2))));
 229
 230   angle_offset = new_offset;
 231
 232   return;
 233 }
 234
 235 bool Sprite::was_made = false;