00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef _STELFADER_HPP_
00021 #define _STELFADER_HPP_
00022
00023 #include <cstdio>
00024 #include <cfloat>
00025
00029 class StelFader
00030 {
00031 public:
00032
00033 StelFader(bool initialState, float minimumValue=0.f, float maximumValue=1.f) : state(initialState), minValue(minimumValue), maxValue(maximumValue) {;}
00034 virtual ~StelFader() {;}
00035
00036 virtual void update(int deltaTicks) = 0;
00037
00038 virtual float getInterstate(void) const = 0;
00039 virtual float getInterstatePercentage(void) const = 0;
00040
00041 virtual StelFader& operator=(bool s) = 0;
00042 bool operator==(bool s) const {return state==s;}
00043 operator bool() const {return state;}
00044 virtual void setDuration(int _duration) {;}
00045 virtual float getDuration(void) = 0;
00046 virtual void setMinValue(float _min) {minValue = _min;}
00047 virtual void setMaxValue(float _max) {maxValue = _max;}
00048 float getMinValue(void) {return minValue;}
00049 float getMaxValue(void) {return maxValue;}
00050 protected:
00051 bool state;
00052 float minValue, maxValue;
00053 };
00054
00057 class BooleanFader : public StelFader
00058 {
00059 public:
00060
00061 BooleanFader(bool initialState=false, float minimumValue=0.f, float maximumValue=1.f) : StelFader(initialState, minimumValue, maximumValue) {;}
00062 ~BooleanFader() {;}
00063
00064 void update(int deltaTicks) {;}
00065
00066 float getInterstate(void) const {return state ? maxValue : minValue;}
00067 float getInterstatePercentage(void) const {return state ? 100.f : 0.f;}
00068
00069 StelFader& operator=(bool s) {state=s; return *this;}
00070 virtual float getDuration(void) {return 0.f;}
00071 protected:
00072 };
00073
00078 class LinearFader : public StelFader
00079 {
00080 public:
00081
00082 LinearFader(int _duration=1000, float minimumValue=0.f, float maximumValue=1.f, bool initialState=false)
00083 : StelFader(initialState, minimumValue, maximumValue)
00084 {
00085 isTransiting = false;
00086 duration = _duration;
00087 interstate = state ? maxValue : minValue;
00088 }
00089
00090 ~LinearFader() {;}
00091
00092
00093 void update(int deltaTicks)
00094 {
00095 if (!isTransiting) return;
00096 counter+=deltaTicks;
00097 if (counter>=duration)
00098 {
00099
00100 isTransiting = false;
00101 interstate = targetValue;
00102
00103 }
00104 else
00105 {
00106 interstate = startValue + (targetValue - startValue) * counter/duration;
00107 }
00108 }
00109
00110
00111 float getInterstate(void) const { return interstate;}
00112 float getInterstatePercentage(void) const {return 100.f * (interstate-minValue)/(maxValue-minValue);}
00113
00114
00115 StelFader& operator=(bool s)
00116 {
00117
00118 if(isTransiting) {
00119
00120 if(s == state) return *this;
00121
00122
00123 state = s;
00124 counter = duration - counter;
00125 float temp = startValue;
00126 startValue = targetValue;
00127 targetValue = temp;
00128
00129 } else {
00130
00131 if(state == s) return *this;
00132
00133
00134 state = s;
00135 startValue = s ? minValue : maxValue;
00136 targetValue = s ? maxValue : minValue;
00137 counter=0;
00138 isTransiting = true;
00139 }
00140 return *this;
00141 }
00142
00143 void setDuration(int _duration) {duration = _duration;}
00144 virtual float getDuration(void) {return duration;}
00145 void setMaxValue(float _max) {
00146 if(interstate >= maxValue) interstate =_max;
00147 maxValue = _max;
00148 }
00149
00150 protected:
00151 bool isTransiting;
00152 int duration;
00153 float startValue, targetValue;
00154 int counter;
00155 float interstate;
00156 };
00157
00158
00159
00160
00161 class ParabolicFader : public StelFader
00162 {
00163 public:
00164
00165 ParabolicFader(int _duration=1000, float minimumValue=0.f, float maximumValue=1.f, bool initialState=false)
00166 : StelFader(initialState, minimumValue, maximumValue)
00167 {
00168 isTransiting = false;
00169 duration = _duration;
00170 interstate = state ? maxValue : minValue;
00171 }
00172
00173 ~ParabolicFader() {;}
00174
00175
00176 void update(int deltaTicks)
00177 {
00178 if (!isTransiting) return;
00179 counter+=deltaTicks;
00180 if (counter>=duration)
00181 {
00182
00183 isTransiting = false;
00184 interstate = targetValue;
00185
00186 }
00187 else
00188 {
00189 interstate = startValue + (targetValue - startValue) * counter/duration;
00190 interstate *= interstate;
00191 }
00192
00193
00194 }
00195
00196
00197 float getInterstate(void) const { return interstate;}
00198 float getInterstatePercentage(void) const {return 100.f * (interstate-minValue)/(maxValue-minValue);}
00199
00200
00201 StelFader& operator=(bool s)
00202 {
00203
00204 if(isTransiting) {
00205
00206 if(s == state) return *this;
00207
00208
00209 state = s;
00210 counter = duration - counter;
00211 float temp = startValue;
00212 startValue = targetValue;
00213 targetValue = temp;
00214
00215 } else {
00216
00217 if(state == s) return *this;
00218
00219
00220 state = s;
00221 startValue = s ? minValue : maxValue;
00222 targetValue = s ? maxValue : minValue;
00223 counter=0;
00224 isTransiting = true;
00225 }
00226 return *this;
00227 }
00228
00229 void setDuration(int _duration) {duration = _duration;}
00230 virtual float getDuration(void) {return duration;}
00231 protected:
00232 bool isTransiting;
00233 int duration;
00234 float startValue, targetValue;
00235 int counter;
00236 float interstate;
00237 };
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273 #endif // _STELFADER_HPP_