No OneTemporary
Actions

Authored By

Unknown

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/allegro5/bitmap.cpp b/util/allegro5/bitmap.cpp
	index d3ef9b04..9ac1604f 100644
	--- a/util/allegro5/bitmap.cpp
	+++ b/util/allegro5/bitmap.cpp
	@@ -1,652 +1,673 @@
	#include <sstream>
	#include <allegro5/allegro_memfile.h>
	#include "util/debug.h"

	static const int rgb_r_shift_16 = 0;
	static const int rgb_g_shift_16 = 5;
	static const int rgb_b_shift_16 = 11;

	static inline int pack565(unsigned char red, unsigned char green, unsigned char blue){
	return (((red >> 3) << rgb_r_shift_16) \|
	((green >> 2) << rgb_g_shift_16) \|
	((blue >> 3) << rgb_b_shift_16));
	}

	/* from allegro4 */
	static inline void unpack565(int color, unsigned char * red, unsigned char * green, unsigned char * blue){
	static int _rgb_scale_5[32] = {
	0, 8, 16, 24, 33, 41, 49, 57,
	66, 74, 82, 90, 99, 107, 115, 123,
	132, 140, 148, 156, 165, 173, 181, 189,
	198, 206, 214, 222, 231, 239, 247, 255
	};

	static int _rgb_scale_6[64] = {
	0, 4, 8, 12, 16, 20, 24, 28,
	32, 36, 40, 44, 48, 52, 56, 60,
	65, 69, 73, 77, 81, 85, 89, 93,
	97, 101, 105, 109, 113, 117, 121, 125,
	130, 134, 138, 142, 146, 150, 154, 158,
	162, 166, 170, 174, 178, 182, 186, 190,
	195, 199, 203, 207, 211, 215, 219, 223,
	227, 231, 235, 239, 243, 247, 251, 255
	};

	*red = _rgb_scale_5[(color >> rgb_r_shift_16) & 0x1F];
	*green = _rgb_scale_6[(color >> rgb_g_shift_16) & 0x3F];
	*blue = _rgb_scale_5[(color >> rgb_b_shift_16) & 0x1F];
	}

	int Bitmap::MaskColor(){
	static int mask = makeColor(255, 0, 255);
	return mask;
	}

	static const int WINDOWED = 0;
	static const int FULLSCREEN = 1;

	Bitmap * Bitmap::Screen = NULL;
	static Bitmap * Scaler = NULL;

	Bitmap::Bitmap():
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	/* TODO */
	}

	Bitmap::Bitmap( const char * load_file ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	internalLoadFile(load_file);
	}

	Bitmap::Bitmap( const std::string & load_file ):
	own(NULL),
	mustResize(false){
	internalLoadFile(load_file.c_str());
	}

	Bitmap::Bitmap(ALLEGRO_BITMAP * who, bool deep_copy):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	if (deep_copy){
	ALLEGRO_BITMAP * clone = al_clone_bitmap(who);
	getData().setBitmap(clone);
	own = new int;
	*own = 1;
	} else {
	getData().setBitmap(who);
	}
	}

	Bitmap::Bitmap(int width, int height):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	ALLEGRO_BITMAP * bitmap = al_create_bitmap(width, height);
	if (bitmap == NULL){
	std::ostringstream out;
	out << "Could not create bitmap with dimensions " << width << ", " << height;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	getData().setBitmap(bitmap);
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	if (deep_copy){
	ALLEGRO_BITMAP * clone = al_clone_bitmap(copy.getData().getBitmap());
	getData().setBitmap(clone);
	own = new int;
	*own = 1;
	} else {
	getData().setBitmap(copy.getData().getBitmap());
	own = copy.own;
	if (own){
	*own += 1;
	}
	}
	}

	enum Format{
	PNG,
	GIF,
	};

	Bitmap Bitmap::memoryPCX(unsigned char * const data, const int length, const bool mask){
	/* TODO */
	return Bitmap();
	}

	void Bitmap::replaceColor(int original, int replaced){
	/* TODO */
	}

	static ALLEGRO_BITMAP * memoryGIF(const char * data, int length){
	ALLEGRO_FILE * memory = al_open_memfile((void *) data, length, "r");
	al_fclose(memory);

	/* FIXME: get gif addon for a5 */

	#if 0
	RGB * palette = NULL;
	/* algif will close the packfile for us in both error and success cases */
	BITMAP * gif = load_gif_packfile(pack, palette);
	if (!gif){
	al_fclose(memory);
	// pack_fclose(pack);
	ostringstream out;
	out <<"Could not load gif from memory: " << (void*) data << " length " << length;
	throw LoadException(__FILE__, __LINE__, out.str());
	}

	BITMAP * out = create_bitmap(gif->w, gif->h);
	blit(gif, out, 0, 0, 0, 0, gif->w, gif->h);
	destroy_bitmap(gif);
	// pack_fclose(pack);
	#endif

	ALLEGRO_BITMAP * out = NULL;

	return out;
	}

	void Bitmap::internalLoadFile(const char * path){
	this->path = path;
	ALLEGRO_BITMAP * loaded = al_load_bitmap(path);
	+ if (loaded == NULL){
	+ std::ostringstream out;
	+ out << "Could not load file '" << path << "'";
	+ throw BitmapException(__FILE__, __LINE__, out.str());
	+ }
	getData().setBitmap(loaded);
	/*
	ALLEGRO_BITMAP * loaded = IMG_Load(path);
	if (loaded){
	getData().setSurface(optimizedSurface(loaded));
	SDL_FreeSurface(loaded);
	} else {
	std::ostringstream out;
	out << "Could not load file '" << path << "'";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	*/
	own = new int;
	*own = 1;
	}

	static ALLEGRO_BITMAP * load_bitmap_from_memory(const char * data, int length, Format type){
	switch (type){
	case PNG : {
	break;
	}
	case GIF : {
	return memoryGIF(data, length);
	break;
	}
	}
	throw Exception::Base(__FILE__, __LINE__);
	}

	Bitmap::Bitmap(const char * data, int length):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	Format type = GIF;
	getData().setBitmap(load_bitmap_from_memory(data, length, type));
	if (getData().getBitmap() == NULL){
	std::ostringstream out;
	out << "Could not create bitmap from memory";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const Bitmap & copy, int x, int y, int width, int height ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	ALLEGRO_BITMAP * his = copy.getData().getBitmap();
	if (x < 0)
	x = 0;
	if (y < 0)
	y = 0;
	if (width + x > al_get_bitmap_width(his)){
	width = al_get_bitmap_width(his) - x;
	}
	if (height + y > al_get_bitmap_height(his)){
	height = al_get_bitmap_height(his) - y;
	}

	ALLEGRO_BITMAP * sub = al_create_sub_bitmap(his, x, y, width, height);
	getData().setBitmap(sub);

	own = new int;
	*own = 1;
	}

	int Bitmap::getWidth() const {
	if (getData().getBitmap() != NULL){
	return al_get_bitmap_width(getData().getBitmap());
	}

	return 0;
	}

	int Bitmap::getRed(int color){
	unsigned char red, green, blue;
	unpack565(color, &red, &green, &blue);
	return red;
	}

	int Bitmap::getGreen(int color){
	unsigned char red, green, blue;
	unpack565(color, &red, &green, &blue);
	return green;
	}

	int Bitmap::getBlue(int color){
	unsigned char red, green, blue;
	unpack565(color, &red, &green, &blue);
	return blue;
	}

	int Bitmap::makeColor(int red, int blue, int green){
	return pack565(red, blue, green);
	}

	int Bitmap::getHeight() const {
	if (getData().getBitmap() != NULL){
	return al_get_bitmap_height(getData().getBitmap());
	}

	return 0;
	}

	int Bitmap::setGraphicsMode(int mode, int width, int height){
	initializeExtraStuff();
	switch (mode){
	case FULLSCREEN: {
	al_set_new_display_flags(ALLEGRO_FULLSCREEN);
	break;
	}
	case WINDOWED: {
	al_set_new_display_flags(ALLEGRO_WINDOWED \| ALLEGRO_RESIZABLE);
	break;
	}
	default: break;
	}
	ALLEGRO_DISPLAY * display = al_create_display(width, height);
	+ if (display == NULL){
	+ std::ostringstream out;
	+ out << "Could not create display with dimensions " << width << ", " << height;
	+ throw BitmapException(__FILE__, __LINE__, out.str());
	+ }
	Screen = new Bitmap(al_get_backbuffer(display));
	Scaler = new Bitmap(width, height);
	return 0;
	}

	int Bitmap::getPixel(const int x, const int y) const {
	ALLEGRO_COLOR color = al_get_pixel(getData().getBitmap(), x, y);
	return pack565(color.r, color.g, color.b);
	}

	void Bitmap::putPixel(int x, int y, int pixel) const {
	/* TODO */
	}

	void Bitmap::putPixelNormal(int x, int y, int col) const {
	putPixel(x, y, col);
	}

	void Bitmap::fill(int color) const {
	unsigned char red, green, blue;
	unpack565(color, &red, &green, &blue);
	- al_set_target_bitmap(getData().getBitmap());
	+ // al_set_target_bitmap(getData().getBitmap());
	al_clear_to_color(al_map_rgb(red, green, blue));
	}

	void Bitmap::transBlender( int r, int g, int b, int a ){
	/* TODO */
	/*
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.currentBlender = ::transBlender;
	*/
	}

	void Bitmap::Stretch( const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const {
	/* TODO */
	}

	void Bitmap::StretchBy2( const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::StretchBy4( const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::drawRotate( const int x, const int y, const int angle, const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who ) const {
	/* TODO */
	}

	void Bitmap::Blit(const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where) const {
	// double start = al_get_time();
	- al_set_target_bitmap(where.getData().getBitmap());
	+ // al_set_target_bitmap(where.getData().getBitmap());
	+ // al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	+ /*
	+ if (&where != Screen){
	+ al_draw_bitmap(getData().getBitmap(), wx, wy, 0);
	+ }
	+ */
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	al_draw_bitmap(getData().getBitmap(), wx, wy, 0);
	- if (&where == Screen){
	- al_flip_display();
	- }
	/*
	double end = al_get_time();
	Global::debug(0) << "Draw in " << (end - start) << " seconds" << std::endl;
	*/
	}

	void Bitmap::drawHFlip(const int x, const int y, const Bitmap & where) const {
	/* TODO */
	}

	void Bitmap::drawHFlip(const int x, const int y, Filter * filter, const Bitmap & where) const {
	/* TODO */
	}

	void Bitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::BlitMasked(const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where) const {
	/* TODO */
	}

	void Bitmap::BlitToScreen(const int upper_left_x, const int upper_left_y) const {
	+#if 0
	if (getWidth() != Screen->getWidth() \|\| getHeight() != Screen->getHeight()){
	/*
	this->Blit( upper_left_x, upper_left_y, *Buffer );
	Buffer->Stretch(*Scaler);
	Scaler->Blit(0, 0, 0, 0, *Screen);
	*/

	this->Stretch(*Scaler, 0, 0, getWidth(), getHeight(), upper_left_x, upper_left_y, Scaler->getWidth(), Scaler->getHeight());
	Scaler->Blit(0, 0, 0, 0, *Screen);
	} else {
	this->Blit(upper_left_x, upper_left_y, *Screen);
	}
	+#endif
	+ /*
	+ if (&where == Screen){
	+ al_flip_display();
	+ }
	+ */
	+ al_flip_display();
	}

	void Bitmap::BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const {
	/* TODO */
	}

	void Bitmap::draw(const int x, const int y, const Bitmap & where) const {
	- al_set_target_bitmap(where.getData().getBitmap());
	- al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	+ // al_set_target_bitmap(where.getData().getBitmap());
	+ // al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	al_draw_bitmap(getData().getBitmap(), x, y, 0);
	}

	void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where) const {
	/* TODO */
	}

	void Bitmap::hLine( const int x1, const int y, const int x2, const int color ) const {
	/* TODO */
	}

	void Bitmap::vLine( const int x1, const int y, const int x2, const int color ) const {
	/* TODO */
	}

	void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	/* TODO */
	}

	void Bitmap::floodfill( const int x, const int y, const int color ) const {
	/* TODO */
	}

	void Bitmap::line( const int x1, const int y1, const int x2, const int y2, const int color ) const {
	/* TODO */
	}

	void Bitmap::circleFill(int x, int y, int radius, int color) const {
	/* TODO */
	}

	void Bitmap::circle(int x, int y, int radius, int color) const {
	/* TODO */
	}

	void Bitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const {
	/* TODO */
	}

	void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, int color ) const {
	/* TODO */
	}

	void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, int color ) const {
	/* TODO */
	}

	void Bitmap::polygon( const int * verts, const int nverts, const int color ) const {
	/* TODO */
	}

	void Bitmap::ellipse( int x, int y, int rx, int ry, int color ) const {
	/* TODO */
	}

	void Bitmap::ellipseFill( int x, int y, int rx, int ry, int color ) const {
	/* TODO */
	}

	void Bitmap::applyTrans(const int color) const {
	/* TODO */
	}

	void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, int edge_color) const {
	/* TODO */
	}

	void Bitmap::drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::save( const std::string & str ) const {
	/* TODO */
	}

	void Bitmap::readLine( std::vector< int > & line, int y ){
	/* TODO */
	}

	void TranslucentBitmap::draw(const int x, const int y, const Bitmap & where) const {
	/* FIXME */
	- al_set_target_bitmap(where.getData().getBitmap());
	- al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
	+ // al_set_target_bitmap(where.getData().getBitmap());
	+ // al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
	al_draw_bitmap(getData().getBitmap(), x, y, 0);
	}

	void LitBitmap::draw( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, Filter * filter,const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const int color ) const {
	/* TODO */
	}

	void TranslucentBitmap::circleFill(int x, int y, int radius, int color) const {
	/* TODO */
	}

	void TranslucentBitmap::putPixelNormal(int x, int y, int color) const {
	/* TODO */
	}

	void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const {
	/* TODO */
	}

	void TranslucentBitmap::rectangleFill(int x1, int y1, int x2, int y2, int color) const {
	/* TODO */
	}

	void TranslucentBitmap::ellipse( int x, int y, int rx, int ry, int color ) const {
	/* TODO */
	}

	void Bitmap::initializeExtraStuff(){
	al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_RGB_565);
	}

	Bitmap & Bitmap::operator=(const Bitmap & copy){
	releaseInternalBitmap();
	path = copy.getPath();
	getData().setBitmap(copy.getData().getBitmap());
	// own = false;
	own = copy.own;
	if (own)
	*own += 1;
	return *this;
	}

	void Bitmap::setClipRect( int x1, int y1, int x2, int y2 ) const {
	/* TODO */
	}

	void Bitmap::getClipRect(int & x1, int & y1, int & x2, int & y2) const {
	/* TODO */
	}

	void Bitmap::destroyPrivateData(){
	al_destroy_bitmap(getData().getBitmap());
	}

	int Bitmap::setGfxModeFullscreen(int x, int y){
	return setGraphicsMode(FULLSCREEN, x, y);
	}

	int Bitmap::setGfxModeWindowed( int x, int y ){
	return setGraphicsMode(WINDOWED, x, y);
	}

	int Bitmap::setGfxModeText(){
	/* TODO */
	return 0;
	}

	bool Bitmap::getError(){
	/* TODO */
	return false;
	}

	void Bitmap::addBlender( int r, int g, int b, int a ){
	/* TODO */
	}

	void Bitmap::differenceBlender( int r, int g, int b, int a ){
	/* TODO */
	}

	void Bitmap::multiplyBlender( int r, int g, int b, int a ){
	/* TODO */
	}

	void Bitmap::drawingMode(int type){
	/* TODO */
	}

	void Bitmap::shutdown(){
	delete Screen;
	Screen = NULL;
	/*
	delete Scaler;
	Scaler = NULL;
	delete Buffer;
	Buffer = NULL;
	*/
	}
	diff --git a/util/gui/animation.cpp b/util/gui/animation.cpp
	index 07f2341c..297f83a8 100644
	--- a/util/gui/animation.cpp
	+++ b/util/gui/animation.cpp
	@@ -1,386 +1,385 @@
	#include "animation.h"

	#include <vector>
	#include <math.h>
	#include <sstream>
	#include "util/token.h"
	#include "util/trans-bitmap.h"
	#include "util/bitmap.h"
	#include "globals.h"
	#include "../debug.h"
	#include "../funcs.h"
	#include "../file-system.h"

	using namespace std;
	using namespace Gui;

	// Temporary solution
	static void renderSprite(const Bitmap & bmp, const int x, const int y, const int alpha, const bool hflip, const bool vflip, const Bitmap & work){
	if (alpha != 255){
	Bitmap::transBlender( 0, 0, 0, alpha );
	if (hflip && !vflip){
	bmp.translucent().drawHFlip(x,y, work);
	} else if (!hflip && vflip){
	bmp.translucent().drawVFlip(x,y, work);
	} else if (hflip && vflip){
	bmp.translucent().drawHVFlip(x,y, work);
	} else if (!hflip && !vflip){
	bmp.translucent().draw(x,y, work);
	}
	} else {
	if (hflip && !vflip){
	bmp.drawHFlip(x,y, work);
	} else if (!hflip && vflip){
	bmp.drawVFlip(x,y, work);
	} else if (hflip && vflip){
	bmp.drawHVFlip(x,y, work);
	} else if (!hflip && !vflip){
	bmp.draw(x,y, work);
	}
	}
	}

	Frame::Frame(const Token *the_token, imageMap &images) throw (LoadException):
	bmp(0),
	time(0),
	horizontalFlip(false),
	verticalFlip(false),
	alpha(255){
	if ( *the_token != "frame" ){
	throw LoadException(__FILE__, __LINE__, "Not an frame");
	}
	const Token & tok = *the_token;
	/* The usual setup of an animation frame is
	// use image -1 to not draw anything, it can be used to get a blinking effect
	(frame (image NUM) (alpha NUM) (offset x y) (hflip 0\|1) (vflip 0\|1) (time NUM))
	*/
	TokenView view = tok.view();
	while (view.hasMore()){
	try{
	const Token * token;
	view >> token;
	if (*token == "image"){
	// get the number
	int num;
	token->view() >> num;
	// now assign the bitmap
	bmp = images[num];
	} else if (*token == "alpha"){
	// get alpha
	token->view() >> alpha;
	} else if (*token == "offset"){
	// Get the offset location it defaults to 0,0
	double x=0, y=0;
	try {
	token->view() >> x >> y;
	} catch (const TokenException & ex){
	}
	offset.set(x,y);
	} else if (*token == "hflip"){
	// horizontal flip
	token->view() >> horizontalFlip;
	} else if (*token == "vflip"){
	// horizontal flip
	token->view() >> verticalFlip;
	} else if (*token == "time"){
	// time to display
	token->view() >> time;
	} else {
	Global::debug( 3 ) << "Unhandled menu attribute: "<<endl;
	if (Global::getDebug() >= 3){
	token->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu animation parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}

	Frame::Frame(Bitmap * bmp):
	bmp(bmp),
	time(0),
	horizontalFlip(false),
	verticalFlip(false),
	alpha(255){
	}

	Frame::~Frame(){
	}

	void Frame::act(double xvel, double yvel){
	scrollOffset.moveBy(xvel,yvel);
	if (scrollOffset.getDistanceFromCenterX() >=bmp->getWidth()){
	scrollOffset.setX(0);
	} else if (scrollOffset.getDistanceFromCenterX() <= -(bmp->getWidth())){
	scrollOffset.setX(0);
	}
	if (scrollOffset.getDistanceFromCenterY() >=bmp->getHeight()){
	scrollOffset.setY(0);
	} else if (scrollOffset.getDistanceFromCenterY() <= -(bmp->getHeight())){
	scrollOffset.setY(0);
	}
	}

	static bool closeFloat(double a, double b){
	const double epsilon = 0.001;
	return fabs(a-b) < epsilon;
	}

	void Frame::draw(const int xaxis, const int yaxis, const Bitmap & work){
	if (!bmp){
	return;
	}

	if (!closeFloat(scrollOffset.getDistanceFromCenterX(), 0) \|\| !closeFloat(scrollOffset.getDistanceFromCenterY(), 0)){

	// Lets do some scrolling
	Bitmap temp = Bitmap::temporaryBitmap(bmp->getWidth(), bmp->getHeight());
	//AnimationPoint loc;
	AbsolutePoint loc;
	if (scrollOffset.getRelativeX() < 0){
	loc.setX(scrollOffset.getDistanceFromCenterX() + bmp->getWidth());
	} else if (scrollOffset.getRelativeX() > 0){
	loc.setX(scrollOffset.getDistanceFromCenterX() - bmp->getWidth());
	}
	if (scrollOffset.getRelativeY() < 0){
	loc.setY(scrollOffset.getDistanceFromCenterY() + bmp->getHeight());
	} else if (scrollOffset.getRelativeY() > 0){
	loc.setY(scrollOffset.getDistanceFromCenterY() - bmp->getHeight());
	}
	bmp->Blit((int) scrollOffset.getDistanceFromCenterX(), (int) scrollOffset.getDistanceFromCenterY(), temp);
	bmp->Blit((int) scrollOffset.getDistanceFromCenterX(), (int) loc.getY(), temp);
	bmp->Blit((int) loc.getX(), (int) scrollOffset.getDistanceFromCenterY(), temp);
	bmp->Blit((int) loc.getX(), (int) loc.getY(), temp);
	-
	- renderSprite(temp, (int)(xaxis+offset.getDistanceFromCenterX()), (int)(yaxis+offset.getDistanceFromCenterY()), alpha, horizontalFlip, verticalFlip, work);

	+ renderSprite(temp, (int)(xaxis+offset.getDistanceFromCenterX()), (int)(yaxis+offset.getDistanceFromCenterY()), alpha, horizontalFlip, verticalFlip, work);
	} else {
	renderSprite(*bmp, (int)(xaxis+offset.getDistanceFromCenterX()), (int)(yaxis+offset.getDistanceFromCenterY()), alpha, horizontalFlip, verticalFlip, work);
	}
	}

	Animation::Animation(const Token *the_token) throw (LoadException):
	id(0),
	depth(BackgroundBottom),
	ticks(0),
	currentFrame(0),
	loop(0),
	allowReset(true){
	images[-1] = 0;
	std::string basedir = "";
	if ( *the_token != "anim" ){
	throw LoadException(__FILE__, __LINE__, "Not an animation");
	}
	/* The usual setup of an animation is
	The images must be listed prior to listing any frames, basedir can be used to set the directory where the images are located
	loop will begin at the subsequent frame listed after loop
	axis is the location in which the drawing must be placed
	location old - used to render in background or foreground (0 == background [default]\| 1 == foreground)
	depth - used to render in background or foreground space (depth background bottom\|middle\|top) \| (depth foreground bottom\|midle\|top)
	reset - used to allow resetting of animation (0 == no \| 1 == yes [default])
	velocity - used to get a wrapping scroll effect while animating
	window - area in which the item will be contained
	(anim (id NUM)
	(location NUM)
	(depth background\|foreground NUM)
	(basedir LOCATION)
	(image NUM FILE)
	(velocity x y)
	(axis x y)
	(frame "Read comments above in constructor")
	(loop)
	(reset NUM)
	(window x1 y1 x2 y2))
	*/
	const Token & tok = *the_token;
	TokenView view = tok.view();
	while (view.hasMore()){
	try{
	const Token * token;
	view >> token;
	if (*token == "id"){
	// get the id
	token->view() >> id;
	} else if (*token == "location"){
	// translate location to depth
	int location = 0;
	token->view() >> location;
	if (location == 0){
	depth = BackgroundBottom;
	} else if (location == 1){
	depth = ForegroundBottom;
	}
	} else if (*token == "depth"){
	// get the depth
	std::string name, level;
	token->view() >> name >> level;
	if (name == "background"){
	if (level == "bottom"){
	depth = BackgroundBottom;
	} else if (level == "middle"){
	depth = BackgroundMiddle;
	} else if (level == "top"){
	depth = BackgroundTop;
	}
	} else if (name == "foreground"){
	if (level == "bottom"){
	depth = ForegroundBottom;
	} else if (level == "middle"){
	depth = ForegroundMiddle;
	} else if (level == "top"){
	depth = ForegroundTop;
	}
	}
	} else if (*token == "basedir"){
	// set the base directory for loading images
	token->view() >> basedir;
	} else if (*token == "image"){
	// add bitmaps by number to the map
	int number;
	std::string temp;
	token->view() >> number >> temp;
	Bitmap *bmp = new Bitmap(Filesystem::find(Filesystem::RelativePath(basedir + temp)).path());
	if (bmp->getError()){
	delete bmp;
	} else {
	images[number] = bmp;
	}
	} else if (*token == "axis"){
	// Get the axis location it defaults to 0,0
	double x=0, y=0;
	try {
	token->view() >> x >> y;
	} catch (const TokenException & ex){
	}
	axis.set(x,y);
	} else if (*token == "window"){
	// Windowed area where to clip if necessary otherwise it defaults to max
	double x1=0,x2=0, y1=0,y2=0;
	try {
	token->view() >> x1 >> y1 >> x2 >> y2;
	} catch (const TokenException & ex){
	}
	window.set(x1,y1,x2,y2);
	} else if (*token == "velocity"){
	// This allows the animation to get a wrapping scroll action going on
	double x=0, y=0;
	try {
	token->view() >> x >> y;
	} catch (const TokenException & ex){
	}
	velocity.set(x,y);
	} else if (*token == "frame"){
	// new frame
	Frame *frame = new Frame(token, images);
	frames.push_back(frame);
	} else if (*token == "loop"){
	// start loop here
	int l;
	token->view() >> l;
	if (l >= (int)frames.size()){
	ostringstream out;
	out << "Loop location is larger than the number of frames. Loop: " << loop << " Frames: " << frames.size();
	throw LoadException(__FILE__, __LINE__, out.str());
	}
	loop = l;
	} else if (*token == "reset"){
	// Allow reset of animation
	token->view() >> allowReset;
	} else {
	Global::debug( 3 ) << "Unhandled menu attribute: "<<endl;
	if (Global::getDebug() >= 3){
	token->print(" ");
	}
	}
	} catch ( const TokenException & ex ) {
	throw LoadException(__FILE__, __LINE__, ex, "Menu animation parse error");
	} catch ( const LoadException & ex ) {
	throw ex;
	}
	}
	}

	Animation::Animation(const std::string & background) throw (LoadException):
	id(0),
	depth(BackgroundBottom),
	ticks(0),
	currentFrame(0),
	loop(0),
	allowReset(true){
	// add bitmap
	Bitmap *bmp = new Bitmap(Filesystem::find(Filesystem::RelativePath(background)).path());
	if (bmp->getError()){
	delete bmp;
	throw LoadException(__FILE__,__LINE__, "Problem loading file: " + background);
	} else {
	images[0] = bmp;
	}
	Frame *frame = new Frame(bmp);
	frames.push_back(frame);
	}

	Animation::Animation(Bitmap * image):
	id(0),
	depth(BackgroundBottom),
	ticks(0),
	currentFrame(0),
	loop(0),
	allowReset(true){
	images[0] = image;
	Frame *frame = new Frame(image);
	frames.push_back(frame);
	}

	Animation::~Animation(){
	for (std::vector<Frame *>::iterator i = frames.begin(); i != frames.end(); ++i){
	if (*i){
	delete *i;
	}
	}

	for (imageMap::iterator i = images.begin(); i != images.end(); ++i){
	if (i->second){
	delete i->second;
	}
	}
	}
	void Animation::act(){
	// Used for scrolling
	for (std::vector<Frame *>::iterator i = frames.begin(); i != frames.end(); ++i){
	(*i)->act(velocity.getRelativeX(), velocity.getRelativeY());
	}
	if( frames[currentFrame]->time != -1 ){
	ticks++;
	if(ticks >= frames[currentFrame]->time){
	ticks = 0;
	forwardFrame();
	}
	}
	}
	void Animation::draw(const Bitmap & work){
	/* should use sub-bitmaps here */
	// Set clip from the axis default is 0,0,bitmap width, bitmap height
	work.setClipRect(-(window.getPosition().getDistanceFromCenterX()),-(window.getPosition().getDistanceFromCenterY()),work.getWidth() - window.getPosition2().getDistanceFromCenterX(),work.getHeight() - window.getPosition2().getDistanceFromCenterY());
	frames[currentFrame]->draw(axis.getDistanceFromCenterX(), axis.getDistanceFromCenterY(),work);
	work.setClipRect(0,0,work.getWidth(),work.getHeight());
	}

	void Animation::forwardFrame(){
	if (currentFrame < frames.size() -1){
	currentFrame++;
	} else {
	currentFrame = loop;
	}
	}
	void Animation::backFrame(){
	if (currentFrame > loop){
	currentFrame--;
	} else {
	currentFrame = frames.size() - 1;
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 11:30 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68769
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions