gAppManager.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2014 Nitra Games Ltd., Istanbul, Turkey                    *
 *                                                                          *
 * Permission is hereby granted, free of charge, to any person obtaining a  *
 * copy of this software and associated documentation files (the            *
 * "Software"), to deal in the Software without restriction, including      *
 * without limitation the rights to use, copy, modify, merge, publish,      *
 * distribute, distribute with modifications, sublicense, and/or sell       *
 * copies of the Software, and to permit persons to whom the Software is    *
 * furnished to do so, subject to the following conditions:                 *
 *                                                                          *
 * The above copyright notice and this permission notice should not be      *
 * deleted from the source form of the Software.                            *
 *                                                                          *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
 *                                                                          *
 * Except as contained in this notice, the name(s) of the above copyright   *
 * holders shall not be used in advertising or otherwise to promote the     *
 * sale, use or other dealings in this Software without prior written       *
 * authorization.                                                           *
 ****************************************************************************/
 
/****************************************************************************
 * Author: Noyan Culum, 2014-on                                             *
 ****************************************************************************/
 
/*
 * gAppManager.h
 *
 *  Created on: May 6, 2014
 *      Author: noyan
 */
 
#ifndef GAPPMANAGER_H
#define GAPPMANAGER_H
 
#include "gBaseWindow.h"
#include "gEvent.h"
#include "gWindowEvents.h"
#include "gFont.h"
#include "gObject.h"
class gGUIAppThread;
 
#include <chrono>
#include <iostream>
#include <mutex>
#include "gGUIManager.h"
 
class gCanvasManager;
class gBaseCanvas;
class gBaseApp;
class gAppManager;
class gGUIFrame;
class gInputManager;
 
void gStartEngine(gBaseApp* baseApp, const std::string& appName, int windowMode, int width, int height, bool isResizable = true);
 
void gStartEngine(gBaseApp* baseApp, const std::string& appName, int windowMode, int unitWidth, int unitHeight, int screenScaling, int width, int height, bool isResizable = true);
 
void gStartEngine(gBaseApp* baseApp, const std::string& appName, int loopMode);
 
extern gAppManager* appmanager;
 
class gAppManager : public gObject {
public:
    gAppManager(const std::string& appName, gBaseApp *baseApp, int width, int height, int windowMode, int unitWidth, int unitHeight, int screenScaling, bool isResizable, int loopMode);
    ~gAppManager();
 
    // Main application
    void runApp();
 
    void initialize();
    void setup();
    void loop();
#ifdef EMSCRIPTEN
    void emscriptenLoop();
#endif
    void stop();
 
    void submitToMainThread(std::function<void()> fn);
 
    std::string getAppName();
 
    gCanvasManager* getCanvasManager();
 
    gGUIManager* getGUIManager();
 
    int getLoopMode();
 
    bool isWindowFocused();
 
    bool callEvent(gEvent& event);
 
    gBaseCanvas* getCurrentCanvas();
 
    void setTargetFramerate(int framerate);
 
    int getTargetFramerate();
 
    int getFramerate();
 
    double getElapsedTime();
 
    gGUIFrame* getCurrentGUIFrame();
 
    void setClipboardString(const std::string& clipboard);
 
    std::string getClipboardString();
 
    int getWindowMode() const { return windowmode; }
 
    gBaseWindow* getWindow() const { return window; }
 
    void setWindowSize(int width, int height);
    void setWindowResizable(bool isResizable);
    void setWindowSizeLimits(int minWidth, int minHeight, int maxWidth, int maxHeight);
 
    void setScreenSize(int width, int height);
 
    void setCurrentCanvas(gBaseCanvas* canvas);
 
    void enableVsync();
    void disableVsync();
 
    void setCurrentGUIFrame(gGUIFrame* guiFrame);
 
    gGUIAppThread* getGUIAppThread();
 
    void setCursor(int cursorId);
    void setCursorMode(gCursorMode cursorMode);
    gCursorMode getCursorMode();
 
    void setWindowIcon(std::string pngFullpath);
    void setWindowIcon(unsigned char* imageData, int w, int h);
 
    void setWindowTitle(const std::string& windowTitle);
 
    bool isJoystickConnected(int joystickId);
    int getJoystickAxesCount(int joystickId);
    const float* getJoystickAxes(int joystickId);
    bool isGamepadEnabled() { return isjoystickenabled; }
    bool isGamepadButtonPressed(int joystickId, int buttonId);
    int getMaxJoystickNum() { return maxjoysticknum; }
    int getMaxJoystickButtonNum() { return maxjoystickbuttonnum; }
 
    std::string getANSILocale();
 
#ifdef ANDROID
    DeviceOrientation getDeviceOrientation() { return deviceorientation; }
    void setDeviceOrientation(DeviceOrientation orientation);
#endif
    
#if TARGET_OS_IPHONE || TARGET_OS_SIMULATOR
    void iosLoop();
#endif // TARGET_OS_IPHONE || TARGET_OS_SIMULATOR
 
private:
    static const int maxjoysticknum = 16;
    static const int maxjoystickbuttonnum = 15;
    static const int maxmousebuttonnum = 3;
 
    using AppClock = std::chrono::steady_clock;
    using AppClockDuration = AppClock::duration;
    using AppClockTimePoint = AppClock::time_point;
 
    gCanvasManager* canvasmanager;
    gGUIManager* guimanager;
 
    EventHandlerFn eventhandler;
    gBaseWindow* window;
    bool usewindow;
    bool isrunning;
    bool setupcomplete;
    std::string appname;
    gBaseApp* app;
    int width;
    int height;
    int windowmode;
    int unitwidth;
    int unitheight;
    int screenscaling;
    bool isresizable;
    int loopmode;
    bool initialized;
    bool initializedbefore;
    bool iswindowfocused;
    std::string ansilocale;
 
    bool ismouseentered;
    bool mousebuttonpressed[maxmousebuttonnum];
    int mousebuttonstate;
 
    AppClockTimePoint starttime, endtime;
    AppClockDuration deltatime;
    AppClockDuration targettimestep;
    uint64_t totaltime;
 
    int framerate;
    int totalupdates;
    int totaldraws;
    int targetframerate;
    bool iscanvasset;
 
    bool isjoystickenabled;
    bool joystickconnected[maxjoysticknum];
    bool joystickbuttonstate[maxjoysticknum][maxjoystickbuttonnum];
    int joystickaxecount;
 
#if GLIST_ANDROID || GLIST_IOS
    DeviceOrientation deviceorientation;
    DeviceOrientation olddeviceorientation;
    bool delayedresize;
#endif
 
    std::vector<std::function<void()>> mainthreadqueue;
    std::mutex mainthreadqueuemutex;
 
private:
 
    void tick();
    void onEvent(gEvent& event);
 
    bool onWindowResizedEvent(gWindowResizeEvent&);
    bool onWindowScaleChangedEvent(gWindowScaleChangedEvent&);
    bool onCharTypedEvent(gCharTypedEvent&);
    bool onKeyPressedEvent(gKeyPressedEvent&);
    bool onKeyReleasedEvent(gKeyReleasedEvent&);
    bool onMouseMovedEvent(gMouseMovedEvent&);
    bool onMouseButtonPressedEvent(gMouseButtonPressedEvent&);
    bool onMouseButtonReleasedEvent(gMouseButtonReleasedEvent&);
    bool onWindowMouseEnterEvent(gWindowMouseEnterEvent&);
    bool onWindowMouseExitEvent(gWindowMouseExitEvent&);
    bool onMouseScrolledEvent(gMouseScrolledEvent&);
    bool onWindowFocusEvent(gWindowFocusEvent&);
    bool onWindowLoseFocusEvent(gWindowLoseFocusEvent&);
    bool onJoystickConnectEvent(gJoystickConnectEvent&);
    bool onJoystickDisconnectEvent(gJoystickDisconnectEvent&);
    bool onAppPauseEvent(gAppPauseEvent&);
    bool onAppResumeEvent(gAppResumeEvent&);
#if GLIST_ANDROID || GLIST_IOS
    bool onDeviceOrientationChangedEvent(gDeviceOrientationChangedEvent&);
    bool onTouchEvent(gTouchEvent&);
#endif
 
    void updateTime();
    void executeQueue();
 
    EventHandlerFn getEventHandler() { return eventhandler; }
 
    static void preciseSleep(double seconds);
 
    gGUIAppThread* guiappthread;
    bool isguiapp;
};
 
#endif //GAPPMANAGER_H