framework.h

Go to the documentation of this file.

#pragma once

#include "util.h"
#include "debug.h"
#include "graphics.h"
#include "sound.h"
#include "input.h"
#include <atomic>
#include <future>
#include <functional>

namespace yappy {
namespace framework {

using error::throwTrace;
using error::FrameworkError;

namespace random {

unsigned int generateRandomSeed();

void setSeed(unsigned int seed);

unsigned int nextRawUInt32();

int nextInt(int a = 0, int b = std::numeric_limits<int>::max());

double nextDouble(double a = 0.0, double max = 1.0);

}   // namespace random

namespace scene {

class SceneBase : private util::noncopyable {
public:
    SceneBase() = default;
    virtual ~SceneBase() = default;

    virtual void update() = 0;
    virtual void render() = 0;
};

class AsyncLoadScene : public SceneBase {
public:
    AsyncLoadScene() = default;
    virtual ~AsyncLoadScene() override;
    virtual void update() final override;

protected:
    virtual void loadOnSubThread(std::atomic_bool &cancel) = 0;
    virtual void updateOnMainThread() = 0;

    void startLoadThread();
    bool isLoading() const;

private:
    std::atomic_bool m_cancel = false;
    std::future<void> m_future;

    void updateLoadStatus();
};

}   // namespace scene


std::vector<std::wstring> parseCommandLine();

inline bool keyPressedAsync(int vKey)
{
    short ret = ::GetAsyncKeyState(vKey);
    return (ret & 0x8000) != 0;
}


using IdString = util::IdString;

template <class T>
class Resource : private util::noncopyable {
public:
    using PtrType = std::shared_ptr<T>;
    using LoadFuncType = std::function<PtrType()>;

    explicit Resource(LoadFuncType loadFunc_) : m_loadFunc(loadFunc_) {}
    ~Resource() = default;

    const PtrType getPtr() const
    {
        std::lock_guard<std::mutex> lock(m_lock);
        if (m_resPtr == nullptr) {
            throwTrace<FrameworkError>("Resource not loaded");
        }
        return m_resPtr;
    }
    void load()
    {
        {
            std::lock_guard<std::mutex> lock(m_lock);
            if (m_resPtr != nullptr) {
                return;
            }
            m_loading = true;
        }
        auto res = m_loadFunc();
        {
            std::lock_guard<std::mutex> lock(m_lock);
            if (!m_loading) {
                throwTrace<FrameworkError>("Multiple load async detected");
            }
            m_loading = false;
            m_resPtr = res;
        }
    }
    void unload() {
        std::lock_guard<std::mutex> lock(m_lock);
        if (!m_loading) {
            throwTrace<FrameworkError>("Unload resource while loading");
        }
        m_resPtr.reset();
    }

private:
    mutable std::mutex m_lock;
    bool m_loading = false;
    PtrType m_resPtr;
    LoadFuncType m_loadFunc;
};


class ResourceManager : private util::noncopyable {
public:
    explicit ResourceManager(size_t resSetCount = 1);
    ~ResourceManager() = default;

    void addTexture(size_t setId, const char *resId,
        std::function<graphics::DGraphics::TextureResourcePtr()> loadFunc);
    void addFont(size_t setId, const char *resId,
        std::function<graphics::DGraphics::FontResourcePtr()> loadFunc);
    void addSoundEffect(size_t setId, const char *resId,
        std::function<sound::XAudio2::SeResourcePtr()> loadFunc);
    void addBgm(size_t setId, const char *resId,
        std::function<sound::XAudio2::BgmResourcePtr()> loadFunc);

    void setSealed(bool sealed);
    bool isSealed();

    void loadResourceSet(size_t setId, std::atomic_bool &cancel);
    void unloadResourceSet(size_t setId);

    const graphics::DGraphics::TextureResourcePtr getTexture(
        size_t setId, const char *resId) const;
    const graphics::DGraphics::FontResourcePtr getFont(
        size_t setId, const char *resId) const;
    const sound::XAudio2::SeResourcePtr getSoundEffect(
        size_t setId, const char *resId) const;
    const sound::XAudio2::BgmResourcePtr getBgm(
        size_t setId, const char *resId) const;

private:
    bool m_sealed = true;

    // int setId -> char[16] resId -> Resource<T>
    template <class T>
    using ResMapVec = std::vector<std::unordered_map<IdString, Resource<T>>>;

    ResMapVec<graphics::DGraphics::TextureResource> m_texMapVec;
    ResMapVec<graphics::DGraphics::FontResource>    m_fontMapVec;
    ResMapVec<sound::XAudio2::SeResource>           m_seMapVec;
    ResMapVec<sound::XAudio2::BgmResource>          m_bgmMapVec;
};

class FrameControl : private util::noncopyable {
public:
    FrameControl(uint32_t fps, uint32_t skipCount);
    ~FrameControl() = default;
    bool shouldSkipFrame() const;
    void endFrame();
    double getFramePerSec() const;

private:
    int64_t m_freq;
    int64_t m_counterPerFrame;
    int64_t m_base = 0;
    uint32_t m_skipCount;
    uint32_t m_frameCount = 0;

    double m_fps = 0.0;
    uint32_t m_fpsPeriod;
    uint32_t m_fpsCount = 0;
    int64_t m_fpsBase = 0;
    uint32_t m_fpsFrameAcc = 0;
};

struct AppParam {
    HINSTANCE hInstance = nullptr;
    int nCmdShow = SW_SHOW;
    const wchar_t *wndClsName = L"GameWndCls";
    const wchar_t *title = L"GameApp";
    HICON hIcon = nullptr;
    HICON hIconSm = nullptr;
    uint32_t frameSkip = 0;
    bool showCursor = false;
};

class Application : private util::noncopyable {
public:
    Application(const AppParam &appParam, const graphics::GraphicsParam &graphParam,
        size_t resSetCount);
    virtual ~Application();
    int run();

    HWND getHWnd() { return m_hWnd; }
    void getGraphicsParam(graphics::GraphicsParam *param) { *param = m_graphParam; }
    graphics::DGraphics &graph() { return *m_dg.get(); }
    sound::XAudio2 &sound() { return *m_ds.get(); }
    input::DInput &input() { return *m_di.get(); }

    void addTextureResource(size_t setId, const char *resId, const wchar_t *path);
    void addFontResource(size_t setId, const char *resId,
        const wchar_t *fontName, uint32_t startChar, uint32_t endChar,
        uint32_t w, uint32_t h);
    void addSeResource(size_t setId, const char *resId, const wchar_t *path);
    void addBgmResource(size_t setId, const char *resId, const wchar_t *path);

    void sealResource(bool seal);

    void loadResourceSet(size_t setId, std::atomic_bool &cancel);
    void unloadResourceSet(size_t setId);

    const graphics::DGraphics::TextureResourcePtr getTexture(
        size_t setId, const char *resId) const;
    const graphics::DGraphics::FontResourcePtr getFont(
        size_t setId, const char *resId) const;
    const sound::XAudio2::SeResourcePtr getSoundEffect(
        size_t setId, const char *resId) const;
    const sound::XAudio2::BgmResourcePtr getBgm(
        size_t setId, const char *resId) const;

protected:
    virtual void init() = 0;
    virtual void update() = 0;
    virtual void render() = 0;

private:
    const UINT_PTR TimerEventId = 0xffff0001;

    HWND m_hWnd;
    std::unique_ptr<graphics::DGraphics> m_dg;
    std::unique_ptr<sound::XAudio2> m_ds;
    std::unique_ptr<input::DInput> m_di;
    ResourceManager m_resMgr;

    AppParam m_param;
    graphics::GraphicsParam m_graphParam;
    FrameControl m_frameCtrl;

    void initializeWindow();
    static LRESULT CALLBACK wndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
    LRESULT onSize(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

    void onIdle();
    void updateInternal();
    void renderInternal();
};

class UnsealResource : util::noncopyable {
public:
    explicit UnsealResource(Application &app) : m_app(app)
    {
        m_app.sealResource(false);
    }
    ~UnsealResource()
    {
        m_app.sealResource(true);
    }

private:
    Application &m_app;
};

}   // namespace framework
}   // namespace yappy