app.h

Go to the documentation of this file.

/*
 * This file is part of the Colobot: Gold Edition source code
 * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see http://gnu.org/licenses
 */

#pragma once

#include "common/event.h"
#include "common/language.h"
#include "common/singleton.h"

#include "graphics/core/device.h"

#include "level/level_category.h"


#include <string>
#include <vector>


class CEventQueue;
class CController;
class CSoundInterface;
class CInput;
class CPathManager;
class CConfigFile;
class CSystemUtils;
struct SystemTimeStamp;

namespace Gfx
{
class CEngine;
struct DeviceConfig;
}

struct JoystickDevice
{
    int index;
    std::string name;
    int axisCount;
    int buttonCount;

    JoystickDevice()
        : index(-1), axisCount(0), buttonCount(0) {}
};

enum VideoQueryResult
{
    VIDEO_QUERY_ERROR,
    VIDEO_QUERY_NONE,
    VIDEO_QUERY_ALL,
    VIDEO_QUERY_OK
};

enum ParseArgsStatus
{
    PARSE_ARGS_OK   = 1, 
    PARSE_ARGS_FAIL = 2, 
    PARSE_ARGS_HELP = 3  
};

enum MouseMode
{
    MOUSE_SYSTEM, 
    MOUSE_ENGINE, 
    MOUSE_BOTH,   
    MOUSE_NONE,   
};

enum PerformanceCounter
{
    PCNT_EVENT_PROCESSING, 

    PCNT_UPDATE_ALL,            
    PCNT_UPDATE_ENGINE,         
    PCNT_UPDATE_PARTICLE,       
    PCNT_UPDATE_GAME,           

    PCNT_RENDER_ALL,            
    PCNT_RENDER_PARTICLE,       
    PCNT_RENDER_WATER,          
    PCNT_RENDER_TERRAIN,        
    PCNT_RENDER_OBJECTS,        
    PCNT_RENDER_INTERFACE,      
    PCNT_RENDER_SHADOW_MAP,     

    PCNT_SWAP_BUFFERS,          

    PCNT_ALL,                   

    PCNT_MAX
};

enum DebugMode
{
    DEBUG_SYS_EVENTS = 1 << 0,
    DEBUG_APP_EVENTS = 1 << 1,
    DEBUG_EVENTS     = DEBUG_SYS_EVENTS | DEBUG_APP_EVENTS,
    DEBUG_MODELS     = 1 << 2,
    DEBUG_ALL        = DEBUG_SYS_EVENTS | DEBUG_APP_EVENTS | DEBUG_MODELS
};

struct ApplicationPrivate;

class CApplication : public CSingleton<CApplication>
{
public:
    CApplication(CSystemUtils* systemUtils);
    ~CApplication();

    CEventQueue* GetEventQueue();
    CSoundInterface* GetSound();

public:
    ParseArgsStatus ParseArguments(int argc, char *argv[]);
    bool        Create();
    int         Run();
    int         GetExitCode() const;

    const std::string& GetErrorMessage() const;

    VideoQueryResult GetVideoResolutionList(std::vector<Math::IntPoint> &resolutions,
                                            bool fullScreen, bool resizeable) const;

    Gfx::DeviceConfig GetVideoConfig() const;

    bool        ChangeVideoConfig(const Gfx::DeviceConfig &newConfig);

    void        SuspendSimulation();
    void        ResumeSimulation();
    bool        GetSimulationSuspended() const;

    void        ResetTimeAfterLoading();

    void            SetSimulationSpeed(float speed);
    float           GetSimulationSpeed() const;

    float       GetAbsTime() const;
    long long   GetExactAbsTime() const;

    long long   GetRealAbsTime() const;

    float       GetRelTime() const;
    long long   GetExactRelTime() const;

    long long   GetRealRelTime() const;

    std::vector<JoystickDevice> GetJoystickList() const;

    JoystickDevice GetJoystick() const;

    bool        ChangeJoystick(const JoystickDevice &newJoystick);


    void        SetJoystickEnabled(bool enable);
    bool        GetJoystickEnabled() const;

    void        UpdateJoystick();

    void        UpdateMouse();


    void        SetGrabInput(bool grab);
    bool        GetGrabInput() const;


    void        SetMouseMode(MouseMode mode);
    MouseMode   GetMouseMode() const;

    void        MoveMouse(Math::Point pos);


    void        SetDebugModeActive(DebugMode mode, bool active);
    bool        IsDebugModeActive(DebugMode mode) const;
    static bool ParseDebugModes(const std::string& str, int& debugModes);


    Language    GetLanguage() const;
    char        GetLanguageChar() const;
    void        SetLanguage(Language language);
    static bool ParseLanguage(const std::string& str, Language& language);


    void        SetLowCPU(bool low);
    bool        GetLowCPU() const;


    void        StartPerformanceCounter(PerformanceCounter counter);
    void        StopPerformanceCounter(PerformanceCounter counter);
    float       GetPerformanceCounterData(PerformanceCounter counter) const;

    bool        GetSceneTestMode();

    void        Render();

    void        RenderIfNeeded(int updateRate);

protected:
    bool CreateVideoSurface();

    Event       ProcessSystemEvent();
    Event       CreateVirtualEvent(const Event& sourceEvent);
    TEST_VIRTUAL Event CreateUpdateEvent();
    void        LogEvent(const Event& event);

    bool OpenJoystick();
    void CloseJoystick();

    void InternalResumeSimulation();

    void ResetPerformanceCounters();
    void UpdatePerformanceCountersData();

protected:
    CSystemUtils* m_systemUtils;
    std::unique_ptr<ApplicationPrivate> m_private;
    std::unique_ptr<CEventQueue> m_eventQueue;
    std::unique_ptr<Gfx::CEngine> m_engine;
    std::unique_ptr<Gfx::CDevice> m_device;
    std::unique_ptr<CSoundInterface> m_sound;
    std::unique_ptr<CController> m_controller;
    std::unique_ptr<CConfigFile> m_configFile;
    std::unique_ptr<CInput> m_input;
    std::unique_ptr<CPathManager> m_pathManager;

    int             m_exitCode;
    bool            m_active;
    long            m_debugModes;

    std::string     m_errorMessage;

    Gfx::DeviceConfig m_deviceConfig;
    Gfx::DeviceConfig m_lastDeviceConfig;

    std::string     m_windowTitle;


    SystemTimeStamp* m_baseTimeStamp;
    SystemTimeStamp* m_lastTimeStamp;
    SystemTimeStamp* m_curTimeStamp;

    SystemTimeStamp* m_performanceCounters[PCNT_MAX][2];
    float            m_performanceCountersData[PCNT_MAX];

    long long       m_realAbsTimeBase;
    long long       m_realAbsTime;
    long long       m_realRelTime;

    long long       m_absTimeBase;
    long long       m_exactAbsTime;
    long long       m_exactRelTime;

    float           m_absTime;
    float           m_relTime;

    float           m_simulationSpeed;
    bool            m_simulationSuspended;

    SystemTimeStamp* m_manualFrameLast;
    SystemTimeStamp* m_manualFrameTime;

    std::string     m_graphics;

    MouseMode       m_mouseMode;

    JoystickDevice  m_joystick;
    bool            m_joystickEnabled;
    std::vector<int> m_joyAxeState;
    std::vector<bool> m_joyButtonState;

    LevelCategory   m_runSceneCategory;
    int             m_runSceneRank;

    bool            m_sceneTest;

    Language        m_language;

    bool            m_lowCPU;

    bool            m_resolutionOverride;

    bool            m_headless;

    static char m_languageLocale[50];
};