1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* 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.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
/*
* This code is based on Broken Sword 2.5 engine
*
* Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
*
* Licensed under GNU GPL v2
*
*/
#ifndef SWORD25_ANIMATION_H
#define SWORD25_ANIMATION_H
// Includes
#include "sword25/kernel/common.h"
#include "sword25/gfx/timedrenderobject.h"
namespace Sword25 {
// Forward declarations
class Kernel;
class AnimationResource;
class AnimationTemplate;
class AnimationDescription;
class InputPersistenceBlock;
class Animation : public TimedRenderObject {
friend class RenderObject;
private:
Animation(RenderObjectPtr<RenderObject> parentPtr, const Common::String &fileName);
Animation(RenderObjectPtr<RenderObject> parentPtr, const AnimationTemplate &template_);
Animation(InputPersistenceBlock &reader, RenderObjectPtr<RenderObject> parentPtr, uint handle);
public:
enum ANIMATION_TYPES {
AT_ONESHOT,
AT_LOOP,
AT_JOJO
};
virtual ~Animation();
void play();
void pause();
void stop();
void setFrame(uint nr);
virtual void setPos(int x, int y);
virtual void setX(int x);
virtual void setY(int y);
virtual int getX() const;
virtual int getY() const;
virtual int getAbsoluteX() const;
virtual int getAbsoluteY() const;
/**
@brief Setzt den Alphawert der Animation.
@param Alpha der neue Alphawert der Animation (0 = keine Deckung, 255 = volle Deckung).
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsAlphaAllowed() true zur�ckgibt.
*/
void setAlpha(int alpha);
/**
@brief Setzt die Modulationfarbe der Animation.
@param Color eine 24-Bit Farbe, die die Modulationsfarbe der Animation festlegt.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsColorModulationAllowed() true zur�ckgibt.
*/
void setModulationColor(uint modulationColor);
/**
@brief Setzt den Skalierungsfaktor der Animation.
@param ScaleFactor der Faktor um den die Animation in beide Richtungen gestreckt werden soll.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zur�ckgibt.
*/
void setScaleFactor(float scaleFactor);
/**
@brief Setzt den Skalierungsfaktor der Animation auf der X-Achse.
@param ScaleFactor der Faktor um den die Animation in Richtungen der X-Achse gestreckt werden soll.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zur�ckgibt.
*/
void setScaleFactorX(float scaleFactorX);
/**
@brief Setzt den Skalierungsfaktor der Animation auf der Y-Achse.
@param ScaleFactor der Faktor um den die Animation in Richtungen der Y-Achse gestreckt werden soll.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zur�ckgibt.
*/
void setScaleFactorY(float scaleFactorY);
/**
@brief Gibt den Skalierungsfakter der Animation auf der X-Achse zur�ck.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zur�ckgibt.
*/
float getScaleFactorX() const {
return _scaleFactorX;
}
/**
@brief Gibt den Skalierungsfakter der Animation auf der Y-Achse zur�ck.
@remark Diese Methode darf nur aufgerufen werden, wenn die Methode IsScalingAllowed() true zur�ckgibt.
*/
float getScaleFactorY() const {
return _scaleFactorY;
}
virtual bool persist(OutputPersistenceBlock &writer);
virtual bool unpersist(InputPersistenceBlock &reader);
virtual void frameNotification(int timeElapsed);
ANIMATION_TYPES getAnimationType() const;
int getFPS() const;
int getFrameCount() const;
bool isScalingAllowed() const;
bool isAlphaAllowed() const;
bool isColorModulationAllowed() const;
uint getCurrentFrame() const {
return _currentFrame;
}
const Common::String &getCurrentAction() const;
bool isRunning() const {
return _running;
}
typedef bool (*ANIMATION_CALLBACK)(uint);
void registerLoopPointCallback(ANIMATION_CALLBACK callback, uint data = 0);
void registerActionCallback(ANIMATION_CALLBACK callback, uint data = 0);
void registerDeleteCallback(ANIMATION_CALLBACK Callback, uint Data = 0);
protected:
virtual bool doRender();
private:
enum Direction {
FORWARD,
BACKWARD
};
int _relX;
int _relY;
float _scaleFactorX;
float _scaleFactorY;
uint _modulationColor;
uint _currentFrame;
int _currentFrameTime;
bool _running;
bool _finished;
Direction _direction;
AnimationResource *_animationResourcePtr;
uint _animationTemplateHandle;
bool _framesLocked;
struct ANIMATION_CALLBACK_DATA {
ANIMATION_CALLBACK Callback;
uint Data;
};
Common::Array<ANIMATION_CALLBACK_DATA> _loopPointCallbacks;
Common::Array<ANIMATION_CALLBACK_DATA> _actionCallbacks;
Common::Array<ANIMATION_CALLBACK_DATA> _deleteCallbacks;
/**
@brief Lockt alle Frames.
@return Gibt false zur�ck, falls nicht alle Frames gelockt werden konnten.
*/
bool lockAllFrames();
/**
@brief Unlockt alle Frames.
@return Gibt false zur�ck, falls nicht alles Frames freigegeben werden konnten.
*/
bool unlockAllFrames();
/**
@brief Diese Methode aktualisiert die Parameter (Gr��e, Position) der Animation anhand des aktuellen Frames.
Diese Methode muss bei jedem Framewechsel aufgerufen werden damit der RenderObject-Manager immer aktuelle Daten hat.
*/
void computeCurrentCharacteristics();
/**
@brief Berechnet den Abstand zwischen dem linken Rand und dem Hotspot auf X-Achse in der aktuellen Darstellung.
*/
int computeXModifier() const;
/**
@brief Berechnet den Abstand zwischen dem linken Rand und dem Hotspot auf X-Achse in der aktuellen Darstellung.
*/
int computeYModifier() const;
void initMembers();
void persistCallbackVector(OutputPersistenceBlock &writer, const Common::Array<ANIMATION_CALLBACK_DATA> &vector);
void unpersistCallbackVector(InputPersistenceBlock &reader, Common::Array<ANIMATION_CALLBACK_DATA> &vector);
AnimationDescription *getAnimationDescription() const;
void initializeAnimationResource(const Common::String &fileName);
};
} // End of namespace Sword25
#endif
|
