Scene.h

Go to the documentation of this file.

// Scene.h
//
// Copyright (c) 2010, 2013-2015 Michael Imamura.
//
// Licensed under GrokkSoft HoverRace SourceCode License v1.0(the "License");
// you may not use this file except in compliance with the License.
//
// A copy of the license should have been attached to the package from which
// you have taken this file. If you can not find the license you can not use
// this file.
//
//
// The author makes no representations about the suitability of
// this software for any purpose.  It is provided "as is" "AS IS",
// 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.

#pragma once

#include "../../engine/Util/OS.h"
#include "../../engine/Util/Profiler.h"

namespace HoverRace {
    namespace Control {
        class InputEventController;
    }
}

namespace HoverRace {
namespace Client {

class Scene
{
public:
    enum class Phase
    {
        INITIALIZING,  
        STARTING,  
        RUNNING,  
        STOPPING,  
        STOPPED,  
    };
    enum class State
    {
        INITIALIZING,  
        BACKGROUND,  
        RAISING,  
        FOREGROUND,  
        LOWERING,  
    };

protected:
    struct ConnList
    {
    public:
        ~ConnList()
        {
            Clear();
        }

        template<class T>
        ConnList &operator<<(T &&conn)
        {
            conns.emplace_front(std::forward<decltype(conn)>(conn));
            return *this;
        }

        // This can be noexcept since we check for empty().
        void Clear() noexcept
        {
            // Disconnect the connections in reverse order of add.
            while (!conns.empty()) {
                conns.pop_front();
            }
        }

    private:
        std::forward_list<boost::signals2::scoped_connection> conns;
    };

public:
    Scene(const std::string &name = "Unnamed Scene");
    virtual ~Scene() { }

    Scene &operator=(const Scene&) = delete;

public:
    const std::string &GetName() const { return name; }

    virtual std::ostream &OutputDebugText(std::ostream &oss) const { return oss; }

    void AttachInput(Control::InputEventController &controller);

    void DetachInput(Control::InputEventController &controller);

protected:
    virtual void AttachController(Control::InputEventController &controller,
        ConnList &conns) = 0;

    virtual void DetachController(Control::InputEventController &controller,
        ConnList &conns) = 0;

public:
    virtual void OnScenePushed() { }

    virtual bool IsMouseCursorEnabled() const = 0;

private:
    Util::OS::timestamp_t TimeSincePrevTick(Util::OS::timestamp_t tick)
    {
        return (tick >= prevTick) ?
            Util::OS::TimeDiff(tick, prevTick) :
            0;
    }

public:
    Phase GetPhase() const { return phase; }
    bool SetPhase(Phase phase);

    State GetState() const { return state; }
    bool MoveToForeground();
    bool MoveToBackground();
private:
    bool SetState(State state);

protected:
    void SetPhaseTransitionDuration(Util::OS::timestamp_t ms)
    {
        phaseTransitionDuration = static_cast<double>(ms);
    }

    Util::OS::timestamp_t GetPhaseDuration(
        Util::OS::timestamp_t curTime = Util::OS::Time())
    {
        return (curTime >= phaseTs) ?
            Util::OS::TimeDiff(curTime, phaseTs) :
            0;
    }

    Util::OS::timestamp_t GetStartingPhaseTime()
    {
        return (phase == Phase::STARTING) ?
            GetPhaseDuration() :
            startingPhaseTime;
    }

    Util::OS::timestamp_t GetStateDuration(
        Util::OS::timestamp_t curTime = Util::OS::Time())
    {
        return (curTime >= stateTs) ?
            Util::OS::TimeDiff(curTime, stateTs) :
            0;
    }

    void SetStateTransitionDuration(Util::OS::timestamp_t ms)
    {
        stateTransitionDuration = ms;
        stateTransitionVelocity =
            (ms == 0) ? 1.0 : (1.0 / static_cast<double>(ms));
    }

protected:
    virtual void OnPhaseChanged(Phase oldPhase) { HR_UNUSED(oldPhase); }

    virtual void OnStateChanged(State oldState) { HR_UNUSED(oldState); }

    virtual void OnPhaseTransition(double progress) { HR_UNUSED(progress); }

    virtual void OnStateTransition(double progress) { HR_UNUSED(progress); }

public:
    void AdvanceScene(Util::OS::timestamp_t tick)
    {
        Util::Profiler::Sampler rootSampler(*rootProfiler);
        Util::Profiler::Sampler sampler(*advanceProfiler);
        Advance(tick);
    }

    void PrepareScene()
    {
        Util::Profiler::Sampler rootSampler(*rootProfiler);
        Util::Profiler::Sampler sampler(*prepareProfiler);
        PrepareRender();
    }

    void RenderScene()
    {
        Util::Profiler::Sampler rootSampler(*rootProfiler);
        Util::Profiler::Sampler sampler(*renderProfiler);
        Render();
    }

protected:
    virtual void Advance(Util::OS::timestamp_t tick);
    virtual void PrepareRender() { }
    virtual void Render() = 0;

private:
    std::string name;
    Util::OS::timestamp_t prevTick;
    Phase phase;
    double phaseTransitionDuration;
    Util::OS::timestamp_t phaseTs;  
    Util::OS::timestamp_t startingPhaseTime;
    State state;
    Util::OS::timestamp_t stateTransitionDuration;
    Util::OS::timestamp_t stateTs;  
    double stateTransitionVelocity;
    double statePosition;
    ConnList attachConns;  
protected:
    std::shared_ptr<Util::Profiler> rootProfiler;
    std::shared_ptr<Util::Profiler> advanceProfiler;
    std::shared_ptr<Util::Profiler> prepareProfiler;
    std::shared_ptr<Util::Profiler> renderProfiler;
};

}  // namespace HoverScript
}  // namespace Client