framework2

1
//
2
//  ofxFBXAnimation.cpp
3
//  ofxFBX-Example-Importer
4
//
5
//  Created by Nick Hardeman on 10/30/13.
6
//
7
//
8

9
#include "ofxFBXAnimation.h"
10

11
//--------------------------------------------------------------
12
ofxFBXAnimation::ofxFBXAnimation() {
13
    bPlaying    = true;
14
    bLoop       = true;
15
//    fbxname     = NULL;
16
    bNewFrame   = false;
17
    _speed      = 1.f;
18
    setFramerate( 30.f );
19
    bDone       = false;
20
}
21

22
//--------------------------------------------------------------
23
ofxFBXAnimation::~ofxFBXAnimation() {
24
//    if(fbxname != NULL) {
25
//        delete fbxname;
26
//        fbxname = NULL;
27
//    }
28
}
29

30
//--------------------------------------------------------------
31
void ofxFBXAnimation::setup( FbxTime aStartTime, FbxTime aStopTime, FbxTime aFrameTime ) {
32
    fbxStartTime    = aStartTime;
33
    fbxStopTime     = aStopTime;
34
    fbxFrameTime    = aFrameTime;
35
    
36
    startTimeMillis = (unsigned int)fbxStartTime.GetMilliSeconds();
37
    stopTimeMillis  = (unsigned int)fbxStopTime.GetMilliSeconds();
38
    frameTimeMillis = (unsigned int)fbxFrameTime.GetMilliSeconds();
39
    
40
    fbxCurrentTime  = fbxStartTime;
41
    
42
    lastUpdateTimeMillis = -1;
43
}
44

45
//--------------------------------------------------------------
46
void ofxFBXAnimation::update( float aElapsedTimeSeconds ) {
47
    bNewFrame = false;
48
    
49
//    cout << "speed: " << _speed << endl;
50
    float tspeed            = _speed;
51
    if( tspeed < 0 ) tspeed *= -1.f;
52
    float clampFrameTime    = getFramerate() * tspeed;//ofClamp( getFramerate() * tspeed, 0.0001, 600);
53
    float tframeTime        = (1.f / clampFrameTime) * 1000.f;
54
    
55
    if(bPlaying) {
56
		uint64_t etimeMillis;// = ofGetElapsedTimeMillis();
57
		if (aElapsedTimeSeconds < 0) {
58
			etimeMillis = ofGetElapsedTimeMillis();
59
		}
60
		else {
61
			etimeMillis = aElapsedTimeSeconds * 1000.f;
62
		}
63
		//int etimeMillis = aElapsedTimeSeconds * 1000;
64
		//cout << "etimeMillis: " << etimeMillis << " argMillis: " << (aElapsedTimeSeconds * 1000) << " secs: " << aElapsedTimeSeconds << " | " << ofGetFrameNum() << endl;
65
        
66
        
67
        if(etimeMillis - lastUpdateTimeMillis >= tframeTime ) {
68
            
69
            //needed for when the animation speed is faster than the app framerate. 
70
            if( fabs(_speed) > 1.0 ){
71
                fbxCurrentTime += (fbxFrameTime) * tspeed;
72
            }else{
73
                if( _speed >= 0 ) {
74
                    fbxCurrentTime += (fbxFrameTime);
75
                } else {
76
                    fbxCurrentTime -= (fbxFrameTime);
77
                }
78
            }
79
            
80
            bNewFrame = true;
81
            lastUpdateTimeMillis = etimeMillis;
82
        }
83
        
84
//        if(etimeMillis - lastUpdateTimeMillis >= tframeTime ) {
85
//            bNewFrame = true;
86
//            if( _speed >= 0 ) {
87
//                fbxCurrentTime += (fbxFrameTime);
88
//            } else {
89
//                fbxCurrentTime -= (fbxFrameTime);
90
//            }
91
//            lastUpdateTimeMillis = etimeMillis;
92
//        }
93
    }
94
    
95
        
96
    if( _speed >= 0 ) {
97
        if(fbxCurrentTime > fbxStopTime ) {
98
            bDone = true;
99
            if(bLoop) fbxCurrentTime = fbxStartTime;
100
            else fbxCurrentTime = fbxStopTime;
101
        } else {
102
            bDone = false;
103
        }
104
    } else {
105
        if(fbxCurrentTime < fbxStartTime ) {
106
            bDone = true;
107
            if(bLoop) fbxCurrentTime = fbxStopTime;
108
            else fbxCurrentTime = fbxStartTime;
109
        } else {
110
            bDone = false;
111
        }
112
    }
113
}
114

115
//--------------------------------------------------------------
116
bool ofxFBXAnimation::isFrameNew() {
117
    return bNewFrame;
118
}
119

120
//--------------------------------------------------------------
121
void ofxFBXAnimation::setSpeed( float aSpeed ) {
122
    _speed = aSpeed;
123
}
124

125
//--------------------------------------------------------------
126
float ofxFBXAnimation::getSpeed() {
127
    return _speed;
128
}
129

130
//--------------------------------------------------------------
131
void ofxFBXAnimation::play() {
132
    bPlaying = true;
133
    if( bDone && !bLoop ) {
134
        if( _speed >= 0 ) {
135
            fbxCurrentTime = fbxStartTime;
136
        } else {
137
            fbxCurrentTime = fbxStopTime;
138
        }
139
    }
140
    bDone = false;
141
}
142

143
//--------------------------------------------------------------
144
void ofxFBXAnimation::pause() {
145
    bPlaying = false;
146
}
147

148
//--------------------------------------------------------------
149
void ofxFBXAnimation::stop() {
150
    bPlaying = false;
151
}
152

153
//--------------------------------------------------------------
154
void ofxFBXAnimation::togglePlayPause() {
155
    bPlaying = !bPlaying;
156
}
157

158
//--------------------------------------------------------------
159
bool ofxFBXAnimation::isPlaying() {
160
    return bPlaying;
161
}
162

163
//--------------------------------------------------------------
164
bool ofxFBXAnimation::isPaused() {
165
    return !bPlaying;
166
}
167

168
//--------------------------------------------------------------
169
bool ofxFBXAnimation::isDone() {
170
    return bDone;
171
}
172

173
//--------------------------------------------------------------
174
void ofxFBXAnimation::setLoops( bool aB ) {
175
    bLoop = aB;
176
}
177

178
//--------------------------------------------------------------
179
bool ofxFBXAnimation::getLoops() {
180
    return bLoop;
181
}
182

183
//--------------------------------------------------------------
184
float ofxFBXAnimation::getPosition() {
185
    return ofMap( (unsigned int)fbxCurrentTime.GetMilliSeconds(), startTimeMillis, stopTimeMillis, 0, 1, true );
186
}
187

188
//--------------------------------------------------------------
189
float ofxFBXAnimation::getPositionSeconds() {
190
    return (float)fbxCurrentTime.GetMilliSeconds() / 1000.f;
191
}
192

193
//--------------------------------------------------------------
194
unsigned int ofxFBXAnimation::getPositionMillis() {
195
    return fbxCurrentTime.GetMilliSeconds();
196
}
197

198
//--------------------------------------------------------------
199
int ofxFBXAnimation::getFrameNum() {
200
    return round(getPosition() * (float)getTotalNumFrames());
201
}
202

203
//--------------------------------------------------------------
204
FbxTime ofxFBXAnimation::getCurrentFbxTime() {
205
    return fbxCurrentTime;
206
}
207

208
//--------------------------------------------------------------
209
void ofxFBXAnimation::setFramerate( float aFramerate ) {
210
    _framerate = aFramerate;
211
}
212

213
//--------------------------------------------------------------
214
float ofxFBXAnimation::getFramerate() {
215
    return _framerate;
216
}
217

218
//--------------------------------------------------------------
219
void ofxFBXAnimation::setPosition( float aPct ) {
220
    int ttime = ofMap(aPct, 0.f, 1.f, startTimeMillis, stopTimeMillis, true );
221
    fbxCurrentTime.SetMilliSeconds(ttime);
222
    lastUpdateTimeMillis = -1; // force update of new frame //
223
}
224

225
//--------------------------------------------------------------
226
void ofxFBXAnimation::setFrame( int aFrameNum ) {
227
    float tframe    = ofClamp( aFrameNum, 0, getTotalNumFrames() );
228
    setPosition( tframe / (float)getTotalNumFrames() );
229
//    fbxCurrentTime  = fbxStartTime + fbxFrameTime * tframe;
230
//    lastUpdateTimeMillis = -1; // force update of new frame //
231
}
232

233
//--------------------------------------------------------------
234
unsigned int ofxFBXAnimation::getDurationMillis() {
235
    return (stopTimeMillis - startTimeMillis);
236
}
237

238
//--------------------------------------------------------------
239
float ofxFBXAnimation::getDurationSeconds() {
240
    return (float)getDurationMillis() / 1000.f;
241
}
242

243
//--------------------------------------------------------------
244
int ofxFBXAnimation::getTotalNumFrames() {
245
    return ceil( getDurationMillis() / frameTimeMillis );
246
}
247

248

249

250

251

252

253

254