Engine.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ENGINE_H
#define ENGINE_H

#include <QList>
#include <QObject>
#include <QQuickItem>
#include <QSet>
#include <functional>
#include "renderer/PointerDeclarations.h"
#include "utils/ContactListener.h"
#include "utils/DestructionListener.h"

class Camera;
class Environment;
class InputArea;
class Level;
class LevelInfo;
class LiquidFunDebugDraw;
class QQuickItem;
class QQuickView;
class SoundManager;
class TextureManager;
class TerrainMaterials;
class b2World;

class Engine : public QObject {
    Q_OBJECT
public:

    enum Phase {

        LOGICS_PHASE = 0,

        BEFORE_PHYSICS_PHASE,

        PHYSICS_PHASE,


        AFTER_PHYSICS_PHASE,


        CAMERA_PHASE,

        RENDERING_PHASE,
    };

    static const float UPDATE_FREQUENCY;

    static const float TIME_STEP_S;

    static const float TIME_STEP_MS;

    static const int VELOCITY_ITERATIONS;

    static const int POSITION_ITERATIONS;

    static const int PARTICLE_ITERATIONS;

    virtual ~Engine();

    void init();

    bool isInitialized() const { return mIsInitialized; }

    Q_INVOKABLE bool isPaused() const { return mPausedRefCount != 0; }

    b2World* getWorld() const;

    long long getWorldStepCount() const { return mWorldStepCount; }


    QQmlEngine* getQmlEngine() const;

    QQuickItem* getRoot() const;

    Camera* getCamera() const { return mCamera; }

    Renderer* getRenderer() const { return mRenderer.get(); }

    Q_INVOKABLE SoundManager* getSoundManager() const { return mSoundManager.get(); }

    TextureManager* getTextureManager() const { return mTextureManager.get(); }

    TerrainMaterials* getTerrainMaterials() const { return mTerrainMaterials.get(); }


    ContactListener* getContactListener() const { return mContactListener.get(); }

    Phase getPhase() const { return mPhase; }

    void addChildItem(QQuickItem* item);

    Q_INVOKABLE Level* getLevel() const { return mLevel; }
    // TODO: Consider refactoring into separate Analytics / Tracker class.
    Q_INVOKABLE void setTrackerScreenName(const QString& screenName, bool sendScreenView = true);
    Q_INVOKABLE void sendTrackerEvent(const QString& category, const QString& action);
    Q_INVOKABLE void sendTrackerEvent(const QString& category, const QString& action,
            const QString& label);
    Q_INVOKABLE void sendTrackerEvent(const QString& category, const QString& action,
            const QString& label, long value);
    Q_INVOKABLE void sendTrackerEvent(const QString& category, const QString& action, long value);

    template <typename T>
    void forEach(const std::function<void(T*)>& func) const {
        static QList<T*> sItemCache;

        // Check if we have a valid cache of these items
        if (!mValidCacheSet.contains(&T::staticMetaObject)) {
            sItemCache.clear();
            createItemCache(getRoot(), &sItemCache);
            mValidCacheSet.insert(&T::staticMetaObject);
        }

        for (T* t : sItemCache) {
            func(t);
        }
    }

    template <typename T>
    void invalidateSceneGraphObjectCache() { mValidCacheSet.remove(&T::staticMetaObject); }

    void invalidateSceneGraphObjectCaches() { mValidCacheSet.clear(); }

    // TODO: Provide an invalidate function that is given a const QMetaObject*.
    // It could be used to intelligently traverse the altered sub-tree of the scene graph and only
    // invalidate the affected caches.  However, the problem is the object's meta object changes
    // between calls and is not equal in reference to the static meta object.

    template <typename T>
    void forEach(QObject* root, const std::function<void(T*)>& func) const {
        T* t = qobject_cast<T*>(root);
        if (t) {
            func(t);
        }
        for (QObject* child : root->children()) {
            forEach(child, func);
        }
    }

    void loadLevel(LevelInfo* levelInfo);

    void deleteCurrentLevel();

    // TODO: Split this into two methods: create and getInstance()
    static Engine* getInstance(bool createIfNecessary = true);

public slots:

    void pause();

    void resume();

    void onPlayLevelRequested();

    void onQuitRequested();

    void onSignedIntoCloudChanged(bool signedIntoCloud);

    void onCloudDataLoaded(int statusCode, const QString& data);

    void onOpeningCinematicCompleted(const QString& menuBGMTrack);

    void onDeviceCreate();

    void onDeviceStart();

    void onDeviceResume();

    void onDevicePause();

    void onDeviceStop();

    void onDeviceDestroy();

signals:
    void levelChanged(const QString& levelName, int completionThreshold, int activationThreshold);

    void signedIntoCloudChanged(bool signedIntoCloud);

    void cloudDataLoaded(int statusCode, const QString& data);

    void beforeUpdate();

    void afterUpdate();

    // Signals for forwarding device lifecyle events.
    // See NOTE from device lifecycle slots above.

    void deviceCreate();


    void deviceStart();

    void deviceResume();

    void devicePause();

    void deviceStop();

    void deviceDestroy();

private slots:
    void update();
    void onBeforeSynchronizing();
    void onBeforeRendering();
    void onAfterRendering();
    void onLoadCompleted(bool success);

private:
    // Level needs access to setCurrentLevel and queueWorldForDeletion.
    friend class Level;

    Engine(QObject* parent = nullptr);

    void setCurrentLevel(Level* level);
    void queueWorldForDeletion(b2World* world);

    void startLoad();
    void performLevelChange();
    void setPhase(Phase phase);

    template <typename T>
    void createItemCache(QObject* item, QList<T*>* itemCache) const {
        T* t = qobject_cast<T*>(item);
        if (t) {
            itemCache->push_back(t);
        }
        for (QObject* child : item->children()) {
            createItemCache(child, itemCache);
        }
    }

    void showViewer();
    void hideViewer();
    // This function updates the camera transformations, which has the desired side-effect of
    // forcing the render thread to execute every time it's called. It is almost always called
    // before leaving update().
    void updateCamera();
    void sceneRender();
    void debugRender();
    void synchronizeForRendering();

    bool mIsInitialized = false;
    // The game starts paused.
    int mPausedRefCount = 1;
    long long mWorldStepCount = 0;
    Phase mPhase = LOGICS_PHASE;
    Camera* mCamera = nullptr;
    QQuickItem* mDebugHudItem = nullptr;
    InputArea* mInputArea = nullptr;
    bool mLevelReady = false;
    Level* mLevel = nullptr;
    bool mHasNextLevel = false;
    int mSyncsSinceNextLevelRequest = 0;
    QString mNextLevelName;
    QQuickItem* mLevelLoader = nullptr;
    volatile bool mViewerReady = false;
    std::unique_ptr<QQuickView> mViewer;
    std::unique_ptr<ContactListener> mContactListener;
    std::unique_ptr<DestructionListener> mDestructionListener;
    std::unique_ptr<Renderer> mRenderer;
    std::unique_ptr<RenderList> mRenderList;
    std::unique_ptr<TextureManager> mTextureManager;
    std::unique_ptr<TerrainMaterials> mTerrainMaterials;
    std::unique_ptr<LiquidFunDebugDraw> mDebugDraw;
    std::unique_ptr<SoundManager> mSoundManager;
    // Temporary state to ensure the level gets deleted after the level stops rendering.
    std::unique_ptr<b2World> mWorldToDelete;
    mutable QSet<const QMetaObject*> mValidCacheSet;
    LevelInfo* mInFlightLevelInfo;

    static Engine* sInstance;
};
Q_DECLARE_METATYPE(Engine*)

#endif // ENGINE_H