App Class
Each Unigine-based application has a part, which is called a main loop and does most of the job required for window updating and drawing. The required code can be embedded directly into the main loop of the application as described here. Or it can be handled by the Unigine::Appclass.
For example, the need to use the Unigine::App class can arise when you want to integrate the Unigine engine into a custom application window.
To correctly use the Unigine::Appclass, you should perform the following:
- Include the UnigineApp.h header file into the source code.
- Create a custom class and inherit it from the Unigine::App class.
- Override all of the virtual functions specified in the include/UnigineApp.h file.
- Create the application window and initialize the graphics in your source code.
Unigine Controls the Main Loop
In this case, the engine cycles through the main loop by itself.
Inside the custom class inherited from the Unigine::App class, you should implement virtual functions doUpdate(), doRender(), and doSwap() that must call the update(), render(), swap() functions respectively. These functions request the engine to update, render a world and swap render buffers.
Furthermore, the custom logic, which is implemented in the doUpdate(), doRender(), and doSwap() functions, will be performed on the corresponding stages of the main loop.
#include <UnigineEngine.h>
#include <UnigineApp.h>
#include "AppSystemLogic.h"
#include "AppWorldLogic.h"
#include "AppEditorLogic.h"
using namespace Unigine;
class AppUser : public App {
// main loop
virtual void doUpdate();
virtual void doRender();
virtual void doSwap();
// list of other class methods and variables
// ...
}
void AppUser::doUpdate() {
// some code that will be executed on the engine update
update();
// some more code
}
void AppUser::doRender() {
// some code that will be executed on the engine render() function call
render();
// some more code
}
void AppUser::doSwap() {
// some code that will be executed on the engine swap() function call
swap();
// some more code
}
/*
*/
#ifdef _WIN32
int wmain(int argc,wchar_t *argv[]) {
#else
int main(int argc,char *argv[]) {
#endif
AppSystemLogic system_logic;
AppWorldLogic world_logic;
AppEditorLogic editor_logic;
Unigine::EnginePtr engine(UNIGINE_VERSION,argc,argv);
engine->main(&system_logic,&world_logic,&editor_logic);
return 0;
}Application Controls the Main Loop
In this case, the application decides when update, rendering and swapping should be done.
Therefore, implementations of doUpdate(), doRender(), doSwap() functions can be left empty to ignore engine requests. The update(), render(), and swap() functions are called directly when necessary (e.g. when some message from the operating system is received).
In the example below, the AppUser::main() function manages the main loop: it handles events and call the update(), render() and swap() functions when some specific event occurs.
#include <UnigineEngine.h>
#include <UnigineApp.h>
#include "AppSystemLogic.h"
#include "AppWorldLogic.h"
#include "AppEditorLogic.h"
using namespace Unigine;
class AppUser : public App {
// main loop
virtual void doUpdate();
virtual void doRender();
virtual void doSwap();
// list of other class methods and variables
// ...
}
// empty implementations
void AppUser::doUpdate() { }
void AppUser::doRender() { }
void AppUser::doSwap() { }
// application is smart enough to handle drawing by itself
void AppUser::main() {
// handle events that come from the operating system
// ...
// call the engine update(), render() and swap() functions when necessary
if(some_event_occured) {
paintEvent();
}
}
// the paintEvent() function should be called in AppUser::main()
void AppUser::paintEvent() {
update();
render();
swap();
}
int main(int argc,char **argv) {
AppSystemLogic system_logic;
AppWorldLogic world_logic;
AppEditorLogic editor_logic;
AppUser app;
Engine::init(UNIGINE_VERSION,0,&app,argc,argv);
// run the function that manages the main loop
app.main();
Engine::shutdown();
}