GgApp.h

[詳解]

#pragma once
 
/*
 
ゲームグラフィックス特論用補助プログラム GLFW3 版
 
Copyright (c) 2011-2025 Kohe Tokoi. All Rights Reserved.
 
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,  sublicense,  and/or sell
copies or substantial portions of the Software.
 
The above  copyright notice  and this permission notice  shall be included in
all copies or substantial portions 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
KOHE TOKOI  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.
 
*/

 
// Dear ImGui を使うなら
#if !defined(GG_USE_IMGUI) && !defined(GG_NO_IMGUI)
#  if defined(__has_include)
#    if __has_include(<imgui.h>) || __has_include("imgui.h")
#      define GG_USE_IMGUI
#    endif
#  endif
#endif
 
// OpenXR を使うなら
//#define GG_USE_OPENXR
 
// 使用するマウスのボタン数
#if !defined(GG_BUTTON_COUNT)
#  define GG_BUTTON_COUNT 3
#endif
 
// 使用するユーザインタフェースの数
#if !defined(GG_INTERFACE_COUNT)
#  define GG_INTERFACE_COUNT 5
#endif
 
// 補助プログラム
#include "gg.h"
using namespace gg;
 
// 標準ライブラリ
#include <stdexcept>
#include <iostream>
 
// ImGui の組み込み
#if defined(GG_USE_IMGUI)
#  include "imgui.h"
#  include "imgui_impl_glfw.h"
#  include "imgui_impl_opengl3.h"
#endif
 
// OpenXR ライブラリの組み込み
#if defined(GG_USE_OPENXR)
#  if defined(_WIN32)
#    define XR_USE_PLATFORM_WIN32
#    define XR_USE_GRAPHICS_API_OPENGL
#    define GLFW_EXPOSE_NATIVE_WIN32
#    define GLFW_EXPOSE_NATIVE_WGL
#    include <GLFW/glfw3native.h>
#    include <windows.h>
#    include <unknwn.h>
#    if defined(_MSC_VER)
#      pragma comment(lib, "openxr_loader.lib")
#    endif
#  else
#    if !defined(__gl_h_)
#      define __gl_h_
#    endif
#    define XR_USE_PLATFORM_XLIB
#    define XR_USE_GRAPHICS_API_OPENGL
#    define GLFW_EXPOSE_NATIVE_X11
#    define GLFW_EXPOSE_NATIVE_GLX
#    include <GLFW/glfw3native.h>
#  endif
#  include <openxr/openxr.h>
#  include <openxr/openxr_platform.h>
#  include <algorithm>
#  include <cstdio>
#  include <cstring>
#  include <string>
#  include <utility>
#  include <vector>
#endif

class GgApp
{
public:

  GgApp(int major = 0, int minor = 1);

  GgApp(const GgApp& w) = delete;

  GgApp(GgApp&& w) = default;

  virtual ~GgApp();

  GgApp& operator=(const GgApp& w) = delete;

  GgApp& operator=(GgApp&& w) = default;

  int main(int argc, const char* const* argv);

  class Window
  {
    // ウィンドウの識別子
    GLFWwindow* window{ nullptr };
 
    // ビューポートの横幅と高さ
    std::array<GLsizei, 2> size;
 
    // フレームバッファの横幅と高さ
    std::array<GLsizei, 2> fboSize;
 
#if defined(IMGUI_VERSION)
    // メニューバーの高さ
    GLsizei menubarHeight{ 0 };
#endif
 
    // ビューポートの縦横比
    GLfloat aspect{ 1.0f };
 
    // マウスの移動速度[X/Y/Z]
    std::array<GLfloat, 3> velocity{ 1.0f, 1.0f, 0.1f };
 
    // マウスボタンの状態
    std::array<bool, GG_BUTTON_COUNT> status{};
 
    // ユーザインタフェースのデータ構造
    struct HumanInterface
    {
      // 最後にタイプしたキー
      int lastKey{ 0 };
 
      // 矢印キー
      std::array<std::array<int, 2>, 4> arrow{};
 
      // マウスの現在位置
      std::array<GLfloat, 2> mouse{};
 
      // マウスホイールの回転量
      std::array<GLfloat, 2> wheel{};
 
      // 平行移動量[ボタン][直前/更新][X/Y/Z]
      std::array<std::array<gg::GgVector, 2>, GG_BUTTON_COUNT> translation{};
 
      // トラックボール
      std::array<gg::GgTrackball, GG_BUTTON_COUNT> rotation;
 
      // コンストラクタ
      HumanInterface()
      {
        resetTranslation();
      }
 
      //
      // マウスや矢印キーによる平行移動量を初期化する
      //
      void resetTranslation();
 
      //
      // 平行移動量と回転量を更新する (X, Y のみ, Z は wheel() で計算する)
      //
      void calcTranslation(int button, const std::array<GLfloat, 3>& velocity);
    };
 
    // ヒューマンインタフェースデバイスのデータ
    std::array<HumanInterface, GG_INTERFACE_COUNT> interfaceData;
 
    // ヒューマンインタフェースデバイスの番号
    int interfaceNo{ 0 };
 
    //
    // ユーザー定義のコールバック関数へのポインタ
    //
    void* userPointer{ nullptr };
    void (*resizeFunc)(const Window* window, int width, int height){ nullptr };
    void (*keyboardFunc)(const Window* window, int key, int scancode, int action, int mods){ nullptr };
    void (*mouseFunc)(const Window* window, int button, int action, int mods){ nullptr };
    void (*wheelFunc)(const Window* window, double x, double y){ nullptr };
 
    //
    // ウィンドウのサイズ変更時の処理
    //
    static void resize(GLFWwindow* window, int width, int height);
 
    //
    // キーボードをタイプした時の処理
    //
    static void keyboard(GLFWwindow* window, int key, int scancode, int action, int mods);
 
    //
    // マウスボタンを操作したときの処理
    //
    static void mouse(GLFWwindow* window, int button, int action, int mods);
 
    //
    // マウスホイールを操作した時の処理
    //
    static void wheel(GLFWwindow* window, double x, double y);
 
  public:

    Window(const std::string& title = "GLFW Window", int width = 640, int height = 480,
      int fullscreen = 0, GLFWwindow* share = nullptr);

    Window(const Window& w) = delete;

    Window(Window&& w) noexcept;

    virtual ~Window()
    {
      // ウィンドウが作成されていなければ戻る
      if (!window) return;
 
      // ウィンドウを破棄する
      glfwDestroyWindow(window);
    }

    Window& operator=(const Window& w) = delete;

    Window& operator=(Window&& w) noexcept;

    auto* get() const
    {
      return window;
    }

    void setClose(int flag = GLFW_TRUE) const
    {
      glfwSetWindowShouldClose(window, flag);
    }

    bool shouldClose() const
    {
      // ウィンドウを閉じるべきなら true を返す
      return glfwWindowShouldClose(window) != GLFW_FALSE;
    }

    explicit operator bool();

    void swapBuffers() const;

    void restoreViewport() const
    {
      if (!glfwGetWindowAttrib(window, GLFW_ICONIFIED)) glViewport(0, 0, fboSize[0], fboSize[1]);
    }

    void updateViewport();
 
#if defined(IMGUI_VERSION)
    void setMenubarHeight(GLsizei height)
    {
      // メニューバーの高さを保存する
      menubarHeight = height;
 
      // ビューポートを復帰する
      updateViewport();
    }
#endif

    auto getWidth() const
    {
      return size[0];
    }

    auto getHeight() const
    {
      return size[1];
    }

    auto getFboWidth() const
    {
      return fboSize[0];
    }

    auto getFboHeight() const
    {
      return fboSize[1];
    }

    const auto& getSize() const
    {
      return size;
    }

    void getSize(GLsizei* size) const
    {
      size[0] = getWidth();
      size[1] = getHeight();
    }

    const auto& getFboSize() const
    {
      return fboSize;
    }

    void getFboSize(GLsizei* fboSize) const
    {
      fboSize[0] = getFboWidth();
      fboSize[1] = getFboHeight();
    }

    auto getAspect() const
    {
      return aspect;
    }

    bool getKey(int key) const
    {
#if defined(IMGUI_VERSION)
      // ImGui がキーボードを使うときはキーボードの処理を行わない
      if (ImGui::GetIO().WantCaptureKeyboard) return false;
#endif
 
      return glfwGetKey(window, key) != GLFW_RELEASE;
    }

    void selectInterface(int no)
    {
      assert(static_cast<size_t>(no) < interfaceData.size());
      interfaceNo = no;
    }

    void setVelocity(GLfloat vx, GLfloat vy, GLfloat vz = 0.1f)
    {
      velocity = std::array<GLfloat, 3>{ vx, vy, vz };
    }

    int getLastKey()
    {
      auto& current_if{ interfaceData[interfaceNo] };
      const int key{ current_if.lastKey };
      current_if.lastKey = 0;
      return key;
    }

    auto getArrow(int direction = 0, int mods = 0) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return static_cast<GLfloat>(current_if.arrow[mods & 3][direction & 1]);
    }

    auto getArrowX(int mods = 0) const
    {
      return getArrow(0, mods);
    }

    auto getArrowY(int mods = 0) const
    {
      return getArrow(1, mods);
    }

    void getArrow(GLfloat* arrow, int mods = 0) const
    {
      arrow[0] = getArrowX(mods);
      arrow[1] = getArrowY(mods);
    }

    auto getShiftArrowX() const
    {
      return getArrow(0, 1);
    }

    auto getShiftArrowY() const
    {
      return getArrow(1, 1);
    }

    void getShiftArrow(GLfloat* shift_arrow) const
    {
      shift_arrow[0] = getShiftArrowX();
      shift_arrow[1] = getShiftArrowY();
    }

    auto getControlArrowX() const
    {
      return getArrow(0, 2);
    }

    auto getControlArrowY() const
    {
      return getArrow(1, 2);
    }

    void getControlArrow(GLfloat* control_arrow) const
    {
      control_arrow[0] = getControlArrowX();
      control_arrow[1] = getControlArrowY();
    }

    auto getAltArrowX() const
    {
      return getArrow(0, 3);
    }

    auto getAltArrowY() const
    {
      return getArrow(1, 3);
    }

    void getAltArrow(GLfloat* alt_arrow) const
    {
      alt_arrow[0] = getAltArrowX();
      alt_arrow[1] = getAltArrowY();
    }

    const auto* getMouse() const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.mouse.data();
    }

    void getMouse(GLfloat* position) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      position[0] = current_if.mouse[0];
      position[1] = current_if.mouse[1];
    }

    auto getMouse(int direction) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.mouse[direction & 1];
    }

    auto getMouseX() const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.mouse[0];
    }

    auto getMouseY() const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.mouse[1];
    }

    const auto* getWheel() const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.wheel.data();
    }

    void getWheel(GLfloat* rotation) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      rotation[0] = current_if.wheel[0];
      rotation[1] = current_if.wheel[1];
    }

    auto getWheel(int direction) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.wheel[direction & 1];
    }

    auto getWheelX() const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.wheel[0];
    }

    auto getWheelY() const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      return current_if.wheel[1];
    }

    const auto& getTranslation(int button = GLFW_MOUSE_BUTTON_1) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      assert(button >= GLFW_MOUSE_BUTTON_1 && button < GLFW_MOUSE_BUTTON_1 + GG_BUTTON_COUNT);
      return current_if.translation[button][1];
    }

    auto getTranslationMatrix(int button = GLFW_MOUSE_BUTTON_1) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      assert(button >= GLFW_MOUSE_BUTTON_1 && button < GLFW_MOUSE_BUTTON_1 + GG_BUTTON_COUNT);
      const auto& t{ current_if.translation[button][1] };
 
      gg::GgMatrix m
      {
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        t[0], t[1], t[2], 1.0f
      };
 
      return m;
    }

    auto getScrollMatrix(int button = GLFW_MOUSE_BUTTON_1) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      assert(button >= GLFW_MOUSE_BUTTON_1 && button < GLFW_MOUSE_BUTTON_1 + GG_BUTTON_COUNT);
      const auto& t{ current_if.translation[button][1] };
 
      gg::GgMatrix m
      {
        t[2] + 1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, t[2] + 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        t[0], t[1], 0.0f, 1.0f
      };
 
      return m;
    }

    auto getRotation(int button = GLFW_MOUSE_BUTTON_1) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      assert(button >= GLFW_MOUSE_BUTTON_1 && button < GLFW_MOUSE_BUTTON_1 + GG_BUTTON_COUNT);
      return current_if.rotation[button].getQuaternion();
    }

    auto getRotationMatrix(int button = GLFW_MOUSE_BUTTON_1) const
    {
      const auto& current_if{ interfaceData[interfaceNo] };
      assert(button >= GLFW_MOUSE_BUTTON_1 && button < GLFW_MOUSE_BUTTON_1 + GG_BUTTON_COUNT);
      return current_if.rotation[button].getMatrix();
    }

    void resetRotation()
    {
      // トラックボールを初期化する
      for (auto& tb : interfaceData[interfaceNo].rotation) tb.reset();
    }

    void resetTranslation()
    {
      // 現在のインターフェースの平行移動量を初期化する
      interfaceData[interfaceNo].resetTranslation();
    }

    void reset()
    {
      // トラックボール処理を初期化する
      resetRotation();
 
      // 平行移動量を初期化する
      resetTranslation();
    }

    void* getUserPointer() const
    {
      return userPointer;
    }

    void setUserPointer(void* pointer)
    {
      userPointer = pointer;
    }

    void setResizeFunc(void (*func)(const Window* window, int width, int height))
    {
      resizeFunc = func;
    }

    void setKeyboardFunc(void (*func)(const Window* window, int key, int scancode, int action, int mods))
    {
      keyboardFunc = func;
    }

    void setMouseFunc(void (*func)(const Window* window, int button, int action, int mods))
    {
      mouseFunc = func;
    }

    void setWheelFunc(void (*func)(const Window* window, double x, double y))
    {
      wheelFunc = func;
    }
  };
 
#if defined(GG_USE_OPENXR)
  class OpenXR
  {
  public:

    enum Hand
    {
      Left = 0,   
      Right = 1,  
      Count = 2   
    };
 
  private:
 
    // OpenXR のインスタンスとシステム
    XrInstance instance{ XR_NULL_HANDLE };
    XrSystemId systemId{ XR_NULL_SYSTEM_ID };
 
    // OpenXR のシステムの名前
    std::string systemName;
 
    // OpenXR のセッション
    XrSession session{ XR_NULL_HANDLE };
    XrSessionState sessionState{ XR_SESSION_STATE_UNKNOWN };
 
    // OpenXR の参照空間
    XrSpace appSpace{ XR_NULL_HANDLE };
    XrReferenceSpaceType referenceSpaceType{ XR_REFERENCE_SPACE_TYPE_STAGE };
 
    // ビュー設定とステート
    std::vector<XrViewConfigurationView> views;
    std::vector<XrView> viewStates;
 
    // OpenXR のスワップチェーン
    std::vector<XrSwapchain> swapchains;
    std::vector<std::vector<XrSwapchainImageOpenGLKHR>> swapchainImages;
 
    // OpenXR へのレンダリングに使う FBO とデプスバッファ (ビューの数だけ確保する)
    std::vector<GLuint> openxrFbo;
    std::vector<GLuint> openxrDepth;
 
    // スワップチェーンのカラーフォーマットが sRGB なら true
    bool swapchainIsSrgb{ true };
 
    // 環境の合成方法
    XrEnvironmentBlendMode blendMode{ XR_ENVIRONMENT_BLEND_MODE_OPAQUE };
 
    // フレームの同期状態
    XrFrameState frameState{ XR_TYPE_FRAME_STATE };
    bool isSessionRunning{ false };
 
    // xrBeginFrame() を呼んで xrEndFrame() を呼んでいない状態なら true
    bool frameBegun{ false };
 
    // 視点の姿勢が取得できていれば true
    bool viewPoseValid{ false };
 
    // 初期化が完了していれば true
    bool initialized{ false };
 
    // 各フレームで取得したスワップチェーンイメージのインデックス
    std::vector<uint32_t> currentImageIndex;
 
    // スワップチェーンイメージを取得中のビューなら true
    std::vector<bool> imageAcquired;
 
    // ミラー表示を行うビューの番号, ミラー表示を行わないなら -1
    int mirrorView{ 0 };
 
    // OpenXR のミラー表示を行うウィンドウ
    const Window* window{ nullptr };
 
    // アクションセット
    XrActionSet actionSet{ XR_NULL_HANDLE };
 
    // アクション定義
    XrAction aimPoseAction{ XR_NULL_HANDLE };
    XrAction gripPoseAction{ XR_NULL_HANDLE };
    XrAction triggerAction{ XR_NULL_HANDLE };
    XrAction gripAction{ XR_NULL_HANDLE };
    XrAction thumbstickAction{ XR_NULL_HANDLE };
    XrAction thumbstickClickAction{ XR_NULL_HANDLE };
    XrAction primaryButtonAction{ XR_NULL_HANDLE };
    XrAction secondaryButtonAction{ XR_NULL_HANDLE };
    XrAction menuButtonAction{ XR_NULL_HANDLE };
    XrAction hapticAction{ XR_NULL_HANDLE };
 
    // コントローラーのスペース
    XrSpace aimSpace[Hand::Count]{ XR_NULL_HANDLE, XR_NULL_HANDLE };
    XrSpace gripSpace[Hand::Count]{ XR_NULL_HANDLE, XR_NULL_HANDLE };
 
    // コントローラーの状態キャッシュ
    struct ControllerState
    {
      bool isTracked{ false };
      XrPosef gripPose{ { 0.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, 0.0f } };
      XrPosef aimPose{ { 0.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, 0.0f } };
      float trigger{ 0.0f };
      float grip{ 0.0f };
      std::array<float, 2> thumbstick{ 0.0f, 0.0f };
      bool thumbstickClick{ false };
      bool primaryButton{ false };
      bool secondaryButton{ false };
      bool menuButton{ false };
    };
    ControllerState controllerStates[Hand::Count];
 
    // サポートするパスの文字列
    XrPath handSubactionPath[Hand::Count]{ XR_NULL_PATH, XR_NULL_PATH };
 
    //
    // アクションシステムを初期化する
    //
    void initActions();
 
    //
    // アクション状態を更新する
    //
    void pollActions();
 
    //
    // OpenXR のイベントを処理する
    //
    void pollEvents();
 
    //
    // スワップチェーンを作成する
    //
    void createSwapchains();
 
    //
    // 描画中のフレームを合成器に転送する
    //
    void endFrame();
 
    //
    // OpenXR のハンドルを破棄する (OpenGL の資源には触れない)
    //
    void destroyXr();
 
    //
    // ミラー表示を行う
    //
    void blitMirror() const;
 
    //
    // コンストラクタ
    //
    OpenXR();
 
    //
    // デストラクタ
    //
    virtual ~OpenXR();
 
  public:
 
    // シングルトンなのでコピー・ムーブ禁止
    OpenXR(const OpenXR&) = delete;
    OpenXR& operator=(const OpenXR&) = delete;
    OpenXR(OpenXR&&) = delete;
    OpenXR& operator=(OpenXR&&) = delete;

    static OpenXR& initialize(const Window& window,
      XrReferenceSpaceType spaceType = XR_REFERENCE_SPACE_TYPE_STAGE,
      const char* appName = "GgApp");

    void terminate();

    bool begin();

    void select(int eye);

    void select(int eye, GLfloat* screen, GLfloat* position, GLfloat* orientation);

    void commit(int eye);

    bool submit(bool mirror = true);

    void setMirror(int eye);

    int getMirror() const;

    bool isRunning() const;

    bool isFocused() const;

    const std::string& getSystemName() const;

    gg::GgMatrix getProjectionMatrix(int eye, GLfloat zNear = 0.1f, GLfloat zFar = 100.0f) const;

    gg::GgMatrix getViewMatrix(int eye) const;

    gg::GgMatrix getPoseMatrix(int eye) const;

    gg::GgVector getPosition(int eye) const;

    gg::GgQuaternion getOrientation(int eye) const;

    const XrFovf& getFov(int eye) const;

    const XrPosef& getPose(int eye) const;

    bool isPoseValid() const;

    GLsizei getWidth(int eye = 0) const;

    GLsizei getHeight(int eye = 0) const;

    GLfloat getAspect(int eye = 0) const;

    uint32_t getViewCount() const;

    XrReferenceSpaceType getReferenceSpaceType() const;

    bool isTracked(int hand) const;

    gg::GgMatrix getGripMatrix(int hand) const;

    gg::GgMatrix getAimMatrix(int hand) const;

    gg::GgVector getGripPosition(int hand) const;

    gg::GgQuaternion getGripOrientation(int hand) const;

    gg::GgVector getAimPosition(int hand) const;

    gg::GgQuaternion getAimOrientation(int hand) const;

    float getTrigger(int hand) const;

    float getGrip(int hand) const;

    std::array<float, 2> getThumbstick(int hand) const;

    bool getThumbstickClick(int hand) const;

    bool getPrimaryButton(int hand) const;

    bool getSecondaryButton(int hand) const;

    bool getMenuButton(int hand = Hand::Left) const;

    void applyHapticVibration(int hand, float durationSeconds = 0.1f, float frequency = XR_FREQUENCY_UNSPECIFIED, float amplitude = 0.5f);
  };
#endif

  static std::string getUsername();
};