main.cpp

// dear imgui: standalone example application for GLFW + OpenGL2, using legacy fixed pipeline
// If you are new to dear imgui, see examples/README.txt and documentation at the top of imgui.cpp.
// (GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan/Metal graphics context creation, etc.)

// **DO NOT USE THIS CODE IF YOUR CODE/ENGINE IS USING MODERN OPENGL (SHADERS, VBO, VAO, etc.)**
// **Prefer using the code in the example_glfw_opengl2/ folder**
// See imgui_impl_glfw.cpp for details.

#define NOMINMAX

#include "imgui.h"
#include "imgui_impl_glfw.h"
#include "imgui_impl_opengl2.h"
#include <stdio.h>
#ifdef __APPLE__
#define GL_SILENCE_DEPRECATION
#endif
#include <GLFW/glfw3.h>

#include "pxr/usd/usd/stage.h"
#include "pxr/usd/usdGeom/sphere.h"
#include "pxr/usd/sdf/path.h"

#include "pxr/usdImaging/usdImagingGL/engine.h"
#include "pxr/usdImaging/usdImagingGL/renderParams.h"
#include "pxr/base/gf/camera.h"
#include "pxr/base/gf/vec4d.h"

#include <iostream>

using namespace std;

// [Win32] Our example includes a copy of glfw3.lib pre-compiled with VS2010 to maximize ease of testing and compatibility with old VS compilers.
// To link with VS2010-era libraries, VS2015+ requires linking with legacy_stdio_definitions.lib, which we do using this pragma.
// Your own project should not be affected, as you are likely to link with a newer binary of GLFW that is adequate for your version of Visual Studio.
#if defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS)
#pragma comment(lib, "legacy_stdio_definitions")
#endif
#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR)))) // Size of a static C-style array. Don't use on pointers!

static void glfw_error_callback(int error, const char *description)
{
    fprintf(stderr, "Glfw Error %d: %s\n", error, description);
}

void traverse(pxr::UsdPrim &prim)
{
    const char *name = prim.GetName().GetText();

    if (ImGui::TreeNode(name))
    {
        for (auto &child : prim.GetChildren())
        {
            traverse(child);
        }
        ImGui::TreePop();
    }
}

int main(int, char **)
{
    // Setup window
    glfwSetErrorCallback(glfw_error_callback);
    if (!glfwInit())
        return 1;
    GLFWwindow *window = glfwCreateWindow(1280, 720, "Dear ImGui GLFW+OpenGL2 example", NULL, NULL);
    if (window == NULL)
        return 1;
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1); // Enable vsync

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO &io = ImGui::GetIO();
    (void)io;

    // Setup Dear ImGui style
    ImGui::StyleColorsDark();
    //ImGui::StyleColorsClassic();

    // Setup Platform/Renderer backends
    ImGui_ImplGlfw_InitForOpenGL(window, true);
    ImGui_ImplOpenGL2_Init();

    // Our state
    bool show_demo_window = true;
    bool show_another_window = false;
    ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

    // load Stage
    //auto stage = pxr::UsdStage::CreateInMemory();
    auto stage = pxr::UsdStage::Open("D:/Kitchen_set/Kitchen_set.usd");
    //auto sphere = pxr::UsdGeomSphere::Define(stage, pxr::SdfPath("/TestSphere"));

    auto renderer = new pxr::UsdImagingGLEngine();
    auto renderParams = pxr::UsdImagingGLRenderParams();

    // Main loop
    while (!glfwWindowShouldClose(window))
    {
        glfwPollEvents();

        // Start the Dear ImGui frame
        ImGui_ImplOpenGL2_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        {
            ImGui::SetNextWindowSize(ImVec2(520, 600), ImGuiCond_FirstUseEver);
            ImGui::Begin("New Window");

            if (ImGui::CollapsingHeader("Help"))
            {
                // たためるMenu
                static char str0[128] = "Hello, world!";

                ImGui::InputText("Input Value", str0, IM_ARRAYSIZE(str0));
                ImGui::TextWrapped(str0);
            }

            if (ImGui::TreeNode("Trees"))
            {

                ImGui::Indent();
                ImGui::SmallButton("hoge");
                ImGui::Indent();
                ImGui::SmallButton("hoge2");
                ImGui::TreePop();
            }

            ImGui::End();
        }

        traverse(stage->GetPrimAtPath(pxr::SdfPath("/")));

        // Rendering
        ImGui::Render();
        int display_w, display_h;
        glfwGetFramebufferSize(window, &display_w, &display_h);
        glViewport(0, 0, display_w, display_h);
        glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
        glClear(GL_COLOR_BUFFER_BIT);

        pxr::GfCamera cam;
        auto frustum = cam.GetFrustum();
        renderer->SetRenderViewport(pxr::GfVec4d(0, 0, display_w, display_h));
        renderer->SetCameraState(frustum.ComputeViewMatrix(),
                                frustum.ComputeProjectionMatrix());
        pxr::UsdPrim root = stage->GetPseudoRoot();
        
        renderer->Render(root, renderParams);
        
        ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());

        glfwMakeContextCurrent(window);
        glfwSwapBuffers(window);
    }

    // Cleanup
    ImGui_ImplOpenGL2_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}