framework2

1
/*
2
 * ofMainLoop.cpp
3
 *
4
 *  Created on: Oct 25, 2014
5
 *      Author: arturo
6
 */
7

8
#include "ofMainLoop.h"
9
#include "ofBaseApp.h"
10
#include "ofConstants.h"
11

12
//========================================================================
13
// default windowing
14
#ifdef TARGET_NODISPLAY
15
	#include "ofAppNoWindow.h"
16
#elif defined(TARGET_OF_IOS)
17
	#include "ofAppiOSWindow.h"
18
#elif defined(TARGET_ANDROID)
19
	#include "ofAppAndroidWindow.h"
20
	#include "ofxAndroidUtils.h"
21
	#include "ofxAndroidApp.h"
22
#elif defined(TARGET_RASPBERRY_PI) && defined(TARGET_GLFW_WINDOW)
23
	#include "ofAppGLFWWindow.h"
24
#elif defined(TARGET_RASPBERRY_PI)
25
	#include "ofAppEGLWindow.h"
26
#elif defined(TARGET_EMSCRIPTEN)
27
	#include "ofxAppEmscriptenWindow.h"
28
#else
29
	#include "ofAppGLFWWindow.h"
30
#endif
31

32
ofMainLoop::ofMainLoop()
33
:bShouldClose(false)
34
,status(0)
35
,allowMultiWindow(true)
36
,escapeQuits(true){
37

38
}
39

40
ofMainLoop::~ofMainLoop() {
41
	exit();
42
}
43

44
std::shared_ptr<ofAppBaseWindow> ofMainLoop::createWindow(const ofWindowSettings & settings){
45
#ifdef TARGET_NODISPLAY
46
	shared_ptr<ofAppNoWindow> window = std::make_shared<ofAppNoWindow>();
47
#else
48
	#if defined(TARGET_OF_IOS)
49
	std::shared_ptr<ofAppiOSWindow> window = std::make_shared<ofAppiOSWindow>();
50
	#elif defined(TARGET_ANDROID)
51
	std::shared_ptr<ofAppAndroidWindow> window = std::make_shared<ofAppAndroidWindow>();
52
	#elif (defined(TARGET_RASPBERRY_PI) && defined(TARGET_GLFW_WINDOW))
53
	std::shared_ptr<ofAppGLFWWindow> window = std::make_shared<ofAppGLFWWindow>();
54
	#elif defined(TARGET_RASPBERRY_PI)
55
	std::shared_ptr<ofAppEGLWindow> window = std::make_shared<ofAppEGLWindow>();
56
	#elif defined(TARGET_EMSCRIPTEN)
57
	std::shared_ptr<ofxAppEmscriptenWindow> window = std::make_shared<ofxAppEmscriptenWindow>();
58
	#elif defined(TARGET_OPENGLES)
59
	std::shared_ptr<ofAppGLFWWindow> window = std::make_shared<ofAppGLFWWindow>();
60
	#else
61
	std::shared_ptr<ofAppGLFWWindow> window = std::make_shared<ofAppGLFWWindow>();
62
	#endif
63
#endif
64
	addWindow(window);
65
	window->setup(settings);
66
	return window;
67
}
68

69
void ofMainLoop::run(const std::shared_ptr<ofAppBaseWindow> & window, std::shared_ptr<ofBaseApp> && app){
70
	windowsApps[window] = app;
71
	if(app){
72
		ofAddListener(window->events().setup,app.get(),&ofBaseApp::setup,OF_EVENT_ORDER_APP);
73
		ofAddListener(window->events().update,app.get(),&ofBaseApp::update,OF_EVENT_ORDER_APP);
74
		ofAddListener(window->events().draw,app.get(),&ofBaseApp::draw,OF_EVENT_ORDER_APP);
75
		ofAddListener(window->events().exit,app.get(),&ofBaseApp::exit,OF_EVENT_ORDER_APP);
76
		ofAddListener(window->events().keyPressed,app.get(),&ofBaseApp::keyPressed,OF_EVENT_ORDER_APP);
77
		ofAddListener(window->events().keyReleased,app.get(),&ofBaseApp::keyReleased,OF_EVENT_ORDER_APP);
78
		ofAddListener(window->events().mouseMoved,app.get(),&ofBaseApp::mouseMoved,OF_EVENT_ORDER_APP);
79
		ofAddListener(window->events().mouseDragged,app.get(),&ofBaseApp::mouseDragged,OF_EVENT_ORDER_APP);
80
		ofAddListener(window->events().mousePressed,app.get(),&ofBaseApp::mousePressed,OF_EVENT_ORDER_APP);
81
		ofAddListener(window->events().mouseReleased,app.get(),&ofBaseApp::mouseReleased,OF_EVENT_ORDER_APP);
82
		ofAddListener(window->events().mouseScrolled,app.get(),&ofBaseApp::mouseScrolled,OF_EVENT_ORDER_APP);
83
		ofAddListener(window->events().mouseEntered,app.get(),&ofBaseApp::mouseEntered,OF_EVENT_ORDER_APP);
84
		ofAddListener(window->events().mouseExited,app.get(),&ofBaseApp::mouseExited,OF_EVENT_ORDER_APP);
85
		ofAddListener(window->events().windowResized,app.get(),&ofBaseApp::windowResized,OF_EVENT_ORDER_APP);
86
		ofAddListener(window->events().messageEvent,app.get(),&ofBaseApp::messageReceived,OF_EVENT_ORDER_APP);
87
		ofAddListener(window->events().fileDragEvent,app.get(),&ofBaseApp::dragged,OF_EVENT_ORDER_APP);
88
		ofAddListener(window->events().touchCancelled,app.get(),&ofBaseApp::touchCancelled,OF_EVENT_ORDER_APP);
89
		ofAddListener(window->events().touchDoubleTap,app.get(),&ofBaseApp::touchDoubleTap,OF_EVENT_ORDER_APP);
90
		ofAddListener(window->events().touchDown,app.get(),&ofBaseApp::touchDown,OF_EVENT_ORDER_APP);
91
		ofAddListener(window->events().touchMoved,app.get(),&ofBaseApp::touchMoved,OF_EVENT_ORDER_APP);
92
		ofAddListener(window->events().touchUp,app.get(),&ofBaseApp::touchUp,OF_EVENT_ORDER_APP);
93
#ifdef TARGET_ANDROID
94
		auto androidApp = dynamic_cast<ofxAndroidApp*>(app.get());
95
		if(androidApp){
96
			ofAddListener(ofxAndroidEvents().okPressed,androidApp,&ofxAndroidApp::okPressed,OF_EVENT_ORDER_APP);
97
			ofAddListener(ofxAndroidEvents().cancelPressed,androidApp,&ofxAndroidApp::cancelPressed,OF_EVENT_ORDER_APP);
98
			ofAddListener(ofxAndroidEvents().backPressed,androidApp,&ofxAndroidApp::backPressed,OF_EVENT_ORDER_APP);
99
			ofAddListener(ofxAndroidEvents().networkConnected,androidApp,&ofxAndroidApp::networkConnectedEvent,OF_EVENT_ORDER_APP);
100
			ofAddListener(ofxAndroidEvents().pause,androidApp,&ofxAndroidApp::pause,OF_EVENT_ORDER_APP);
101
			ofAddListener(ofxAndroidEvents().resume,androidApp,&ofxAndroidApp::resume,OF_EVENT_ORDER_APP);
102
			ofAddListener(ofxAndroidEvents().unloadGL,androidApp,&ofxAndroidApp::unloadGL,OF_EVENT_ORDER_APP);
103
			ofAddListener(ofxAndroidEvents().reloadGL,androidApp,&ofxAndroidApp::reloadGL,OF_EVENT_ORDER_APP);
104
			ofAddListener(ofxAndroidEvents().swipe,androidApp,&ofxAndroidApp::swipe,OF_EVENT_ORDER_APP);
105
			ofAddListener(ofxAndroidEvents().deviceOrientationChanged,androidApp,&ofxAndroidApp::deviceOrientationChangedEvent,OF_EVENT_ORDER_APP);
106
		}
107
#endif
108
	}
109
	currentWindow = window;
110
	window->makeCurrent();
111
	if(!windowLoop){
112
		window->events().notifySetup();
113
	}
114
}
115

116
void ofMainLoop::run(std::shared_ptr<ofBaseApp> && app){
117
	if(!windowsApps.empty()){
118
		run(windowsApps.begin()->first, std::move(app));
119
	}
120
}
121

122
int ofMainLoop::loop(){
123
	if(!windowLoop){
124
		while(!bShouldClose && !windowsApps.empty()){
125
			loopOnce();
126
			pollEvents();
127
		}
128
	}else{
129
		windowLoop();
130
	}
131
	return status;
132
}
133

134
void ofMainLoop::loopOnce(){
135
	if(bShouldClose) return;
136
	for(auto i = windowsApps.begin(); !windowsApps.empty() && i != windowsApps.end();){
137
		if(i->first->getWindowShouldClose()){
138
			const auto & window = i->first;
139
			window->close();
140
			windowsApps.erase(i++); ///< i now points at the window after the one which was just erased
141
		}else{
142
			currentWindow = i->first;
143
			i->first->makeCurrent();
144
			i->first->update();
145
			i->first->draw();
146
			i++; ///< continue to next window
147
		}
148
	}
149
	loopEvent.notify(this);
150
}
151

152
void ofMainLoop::pollEvents(){
153
	if(windowPollEvents){
154
		windowPollEvents();
155
	}
156
}
157

158
void ofMainLoop::exit(){
159
	exitEvent.notify(this);
160

161
	for(auto i: windowsApps){
162
		std::shared_ptr<ofAppBaseWindow> window = i.first;
163
		std::shared_ptr<ofBaseApp> app = i.second;
164

165
		if(window == nullptr) {
166
			continue;
167
		}
168
		if(app == nullptr) {
169
			continue;
170
		}
171

172
		ofEventArgs args;
173
		ofNotifyEvent(window->events().exit, args, this);
174

175
		ofRemoveListener(window->events().setup,app.get(),&ofBaseApp::setup,OF_EVENT_ORDER_APP);
176
		ofRemoveListener(window->events().update,app.get(),&ofBaseApp::update,OF_EVENT_ORDER_APP);
177
		ofRemoveListener(window->events().draw,app.get(),&ofBaseApp::draw,OF_EVENT_ORDER_APP);
178
		ofRemoveListener(window->events().exit,app.get(),&ofBaseApp::exit,OF_EVENT_ORDER_APP);
179
		ofRemoveListener(window->events().keyPressed,app.get(),&ofBaseApp::keyPressed,OF_EVENT_ORDER_APP);
180
		ofRemoveListener(window->events().keyReleased,app.get(),&ofBaseApp::keyReleased,OF_EVENT_ORDER_APP);
181
		ofRemoveListener(window->events().mouseMoved,app.get(),&ofBaseApp::mouseMoved,OF_EVENT_ORDER_APP);
182
		ofRemoveListener(window->events().mouseDragged,app.get(),&ofBaseApp::mouseDragged,OF_EVENT_ORDER_APP);
183
		ofRemoveListener(window->events().mousePressed,app.get(),&ofBaseApp::mousePressed,OF_EVENT_ORDER_APP);
184
		ofRemoveListener(window->events().mouseReleased,app.get(),&ofBaseApp::mouseReleased,OF_EVENT_ORDER_APP);
185
		ofRemoveListener(window->events().mouseScrolled,app.get(),&ofBaseApp::mouseScrolled,OF_EVENT_ORDER_APP);
186
		ofRemoveListener(window->events().mouseEntered,app.get(),&ofBaseApp::mouseEntered,OF_EVENT_ORDER_APP);
187
		ofRemoveListener(window->events().mouseExited,app.get(),&ofBaseApp::mouseExited,OF_EVENT_ORDER_APP);
188
		ofRemoveListener(window->events().windowResized,app.get(),&ofBaseApp::windowResized,OF_EVENT_ORDER_APP);
189
		ofRemoveListener(window->events().messageEvent,app.get(),&ofBaseApp::messageReceived,OF_EVENT_ORDER_APP);
190
		ofRemoveListener(window->events().fileDragEvent,app.get(),&ofBaseApp::dragged,OF_EVENT_ORDER_APP);
191
		ofRemoveListener(window->events().touchCancelled,app.get(),&ofBaseApp::touchCancelled,OF_EVENT_ORDER_APP);
192
		ofRemoveListener(window->events().touchDoubleTap,app.get(),&ofBaseApp::touchDoubleTap,OF_EVENT_ORDER_APP);
193
		ofRemoveListener(window->events().touchDown,app.get(),&ofBaseApp::touchDown,OF_EVENT_ORDER_APP);
194
		ofRemoveListener(window->events().touchMoved,app.get(),&ofBaseApp::touchMoved,OF_EVENT_ORDER_APP);
195
		ofRemoveListener(window->events().touchUp,app.get(),&ofBaseApp::touchUp,OF_EVENT_ORDER_APP);
196
#ifdef TARGET_ANDROID
197
		auto androidApp = dynamic_cast<ofxAndroidApp*>(app.get());
198
		if(androidApp){
199
			ofRemoveListener(ofxAndroidEvents().okPressed,androidApp,&ofxAndroidApp::okPressed,OF_EVENT_ORDER_APP);
200
			ofRemoveListener(ofxAndroidEvents().cancelPressed,androidApp,&ofxAndroidApp::cancelPressed,OF_EVENT_ORDER_APP);
201
			ofRemoveListener(ofxAndroidEvents().backPressed,androidApp,&ofxAndroidApp::backPressed,OF_EVENT_ORDER_APP);
202
			ofRemoveListener(ofxAndroidEvents().networkConnected,androidApp,&ofxAndroidApp::networkConnectedEvent,OF_EVENT_ORDER_APP);
203
			ofRemoveListener(ofxAndroidEvents().pause,androidApp,&ofxAndroidApp::pause,OF_EVENT_ORDER_APP);
204
			ofRemoveListener(ofxAndroidEvents().resume,androidApp,&ofxAndroidApp::resume,OF_EVENT_ORDER_APP);
205
			ofRemoveListener(ofxAndroidEvents().unloadGL,androidApp,&ofxAndroidApp::unloadGL,OF_EVENT_ORDER_APP);
206
			ofRemoveListener(ofxAndroidEvents().reloadGL,androidApp,&ofxAndroidApp::reloadGL,OF_EVENT_ORDER_APP);
207
			ofRemoveListener(ofxAndroidEvents().swipe,androidApp,&ofxAndroidApp::swipe,OF_EVENT_ORDER_APP);
208
			ofRemoveListener(ofxAndroidEvents().deviceOrientationChanged,androidApp,&ofxAndroidApp::deviceOrientationChangedEvent,OF_EVENT_ORDER_APP);
209
		}
210
#endif
211
	}
212

213

214
	// reset applications then windows
215
	// so events are present until the
216
	// end of the application
217
	for(auto & window_app: windowsApps){
218
		window_app.second.reset();
219
	}
220
	windowsApps.clear();
221
}
222

223
std::shared_ptr<ofAppBaseWindow> ofMainLoop::getCurrentWindow(){
224
	return currentWindow.lock();
225
}
226

227
void ofMainLoop::setCurrentWindow(const std::shared_ptr<ofAppBaseWindow> & window){
228
	currentWindow = window;
229
}
230

231
void ofMainLoop::setCurrentWindow(ofAppBaseWindow * window){
232
	if(currentWindow.lock().get() == window){
233
		return;
234
	}
235
	for(auto i: windowsApps){
236
		if(i.first.get() == window){
237
			currentWindow = i.first;
238
			break;
239
		}
240
	}
241
}
242

243
std::shared_ptr<ofBaseApp> ofMainLoop::getCurrentApp(){
244
	return windowsApps[currentWindow.lock()];
245
}
246

247
void ofMainLoop::shouldClose(int _status){
248
	for(auto i: windowsApps){
249
		i.first->setWindowShouldClose();
250
	}
251
	bShouldClose = true;
252
	status = _status;
253
}
254

255
void ofMainLoop::setEscapeQuitsLoop(bool quits){
256
	escapeQuits = quits;
257
}
258

259
void ofMainLoop::keyPressed(ofKeyEventArgs & key){
260
	if (key.key == OF_KEY_ESC && escapeQuits == true){				// "escape"
261
		shouldClose(0);
262
	}
263
}
264