Hosting courtesy of Sourceforge

               

---

ImageAnimator.cpp

Go to the documentation of this file.

//
//                                 ImageAnimator.cpp
//                             -------------------
//    begin                : Sat Mar 9 2002
//    copyright           : (C) 2002 by Rob Renaud
//    email                : rrenaud@eden.rutgers.edu
//
//   This program 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.
//

// Program used to make the conveyor belts.  It basically tiles and wraps
// a single .bmp multiple times for multiple frames, and then creates
// a .ani animation file with all the generated BMPs.

#include "draw.h"
#include "../Util/StringUtil.h"
#include "../Util/STL_Helper.h"
#include <vector>
#include <iostream>
#include <cmath>

using namespace std;
using namespace Graphics;

const int SCREEN_WIDTH=640;
const int SCREEN_HEIGHT=480;
const int NUM_IMAGES=10;

enum Direction {
        RIGHT,
        LEFT,
        DOWN,
        UP
};

int main(int argc, char* argv[]) {
        std::vector<SDL_Surface*> surfVec;
        SDL_Surface* srcSurf=NULL;
        try {
                std::string filename;
                std::string extensionlessName;
                std::string extension;
                Direction direction;
                int delta;
                int numFrames;
        
                cout << "Enter filename ";
                cin >> filename;
        
                srcSurf = SDL_LoadBMP(filename.c_str());
                if (srcSurf == NULL) {
                        cout << "Error, couldn't read file " << filename << endl;
                        return 1;
                }
        
                extension = filename.substr(filename.rfind('.'));
                extensionlessName =  filename.substr(0, filename.length()- extension.length());
        
//              cout << "Enter delta ";
                //cin >> delta;
                delta=1;
        
                cout << "Enter number of frames ";
//              cin >> numFrames;
                numFrames=10;
        
                cout << "Enter direction" << endl;
                cout << "1. Right" << endl;
                cout << "2. Left"   << endl;
                cout << "3. Up" << endl;
                cout << "4. Down"       << endl;
                
                int dirChoice;
                cin >> dirChoice;
                
                switch (dirChoice) {
                        case 1: direction = RIGHT; break;
                        case 2: direction = LEFT; break;
                        case 3: direction = UP; break;
                        case 4: direction = DOWN; break;
                        default:
                                cout << "invalid direction" << endl;
                                return 0;
                }               
                
                surfVec.resize(numFrames);
        
                int w = srcSurf->w;
                int h = srcSurf->h;

                cout << "Writing animation file at " << extensionlessName << ".ani" << endl;    
                ofstream animationFile((extensionlessName + ".ani").c_str());
                animationFile << numFrames << endl;
                animationFile << 1 << endl; // draw each frame only once before going to next one
        
                for (int i = 0; i < numFrames; i++) {
                        // this probably makes this 10x slower than neccesary.. but what's 10ms vs 1ms? :)
                        surfVec[i] = SDL_LoadBMP(filename.c_str());
                        SDL_LockSurface(surfVec[i]);
                        int x,y;// switch scoping rules... :(
                        int destLoc;
                        switch (direction) {
                                case LEFT:        // fall through
                                case RIGHT:
                                        for (x = 0; x <  w; x++) {                                      
                                                destLoc = (x + i * delta) % w;                                          
                                                for (y = 0; y <h; y++) {
                                            if (direction == RIGHT) {
                                                                putpixel(surfVec[i],destLoc, y, getpixel(srcSurf, x, y));
                                                        } else  {
                                                                putpixel(surfVec[i], x, y, getpixel(srcSurf, destLoc,y));
                                                        }
                                                }
                                        }
                                        break;
                                case UP:        // fall through
                                case DOWN:
                                        for (y = 0; y < h; y++) {
                                                destLoc = (y + i * delta) %h;                                           
                                                for (x = 0; x < w; x++) {
                                                        if (direction == DOWN) {
                                                                putpixel(surfVec[i], x , destLoc, getpixel(srcSurf, x , y));
                                                        } else {
                                                                putpixel(surfVec[i], x, y, getpixel(srcSurf, x, destLoc));
                                                        }
                                                }
                                        }
                                        break;
                                default: break;                                         
                        }
                        std::string newFilename = extensionlessName + Util::toString(i) + extension;
                        cout << "Writing to " << newFilename << endl;
                        SDL_SaveBMP(surfVec[i], newFilename.c_str());
                        animationFile << newFilename << endl;
                }
                animationFile.close();
        
                SDL_Init(SDL_INIT_VIDEO);
                SDL_Surface* screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 16,
                         SDL_SWSURFACE|  SDL_DOUBLEBUF);
        
                std::vector<AnimatedImage*> images;
                images.resize(NUM_IMAGES);
                for (int i = 0; i < NUM_IMAGES; i++) {
                        images[i] = new AnimatedImage(extensionlessName + ".ani");
                }
                                
                while (!SDL_GetKeyState(NULL)[SDLK_ESCAPE]) {
                        SDL_Rect r;
                        r.y=r.x=100;
                        SDL_PumpEvents();
                        for (int x = 0; x < NUM_IMAGES/2; x++) {
                                r.y=0;
                        //      for (int y = 0; y < SCREEN_HEIGHT / h; y++) {                                                                           
                                        images[x]->drawAt(screen, &r);
                        //              r.y+=h;
                        //      }
                                r.x+=w;
                        }
                        
                        for (int y = NUM_IMAGES/2; y < NUM_IMAGES; y++) {
                                images[y]->drawAt(screen, &r);
                                r.y+=h;
                        }

                        SDL_Delay(50);
                        SDL_Flip(screen);
                }
                Util::freeDynamicContainer(images);
        } catch (Util::GeneralException& e) {
                cout << "Fatal exception:" << e << endl;
        }               
        SDL_UnlockSurface(srcSurf);
        SDL_FreeSurface(srcSurf);
        for (std::vector<SDL_Surface*>::iterator it = surfVec.begin(); it != surfVec.end(); it++) {
                SDL_UnlockSurface(*it);
                SDL_FreeSurface(*it);
        }
        Graphics::ImageManager::destroy();
        SDL_Quit();
        return 0;       
}

---