v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
assimp/contrib/tinyusdz/tinyusdz_repo/examples/openglviewer/main.cc

1796 lines
55 KiB
C++
Raw Normal View History

Init add tinyusdz repo
2024-03-30 02:33:07 +00:00
#include <algorithm>
#include <atomic>
#include <cassert>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <mutex>
#include <thread>
#include <vector>
#if defined(_MSC_VER)
#include <direct.h> // _getcwd
#endif
// GL
//
// glad must be included before glfw3.h
// TODO: Use imgui's imgui_impl_opengl3_loader.h
#if defined(_WIN32)
#if !defined(NOMINMAX)
#define NOMINMAX
#endif
#include <Windows.h>
#endif
#include "glad/glad.h"
//
#include <GLFW/glfw3.h>
// GUI common
#include "../common/imgui/imgui.h"
#include "../common/imgui/imgui_impl_glfw.h"
#include "../common/imgui/imgui_impl_opengl3.h"
#include "../common/trackball.h"
#include "../common/viewport_camera.hh"
// TinyUSDZ
// include relative to openglviewer example cmake top dir for clangd lsp.
#include "external/linalg.h"
#include "io-util.hh"
#include "linear-algebra.hh"
#include "pprinter.hh" // import to_string(tinyusdz::value::***)
#include "tinyusdz.hh"
#include "tydra/render-data.hh"
#include "tydra/scene-access.hh"
#include "value-pprint.hh" // import to_string(tinyusdz::value::***)
// local
#include "shader.hh"
// variable name must match in shaders/***.vert
constexpr auto kAttribPoints = "input_position";
constexpr auto kAttribNormals = "input_normal";
constexpr auto kAttribTexCoordBase = "input_uv";
constexpr auto kAttribTexCoord0 = "input_uv";
constexpr auto kMaxTexCoords = 1; // TODO: multi texcoords
constexpr auto kUniformModelMatrix = "modelMatrix";
constexpr auto kUniformNormalMatrix = "normalMatrix";
constexpr auto kUniformMVPMatrix = "mvp";
constexpr auto kUniformDiffuseTex = "diffuseTex";
constexpr auto kUniformDiffuseTexTransform = "diffuseTexTransform";
constexpr auto kUniformDiffuseTexScaleAndBias =
"diffuseTexScaleAndBias"; // (sx, sy, bx, by)
constexpr auto kUniformNormaTex = "normalTex";
constexpr auto kUniformNormaTexTransform = "normalTexTransform";
constexpr auto kUniformNormalTexScaleAndBias =
"normalTexScaleAndBias"; // (sx, sy, bx, by)
constexpr auto kUniformOcclusionTex = "occlusionlTex";
constexpr auto kUniformOcclusionTexTransform = "occlusionlTexTransform";
constexpr auto kUniformOcclusionTexScaleAndBias =
"occlusionTexScaleAndBias"; // (sx, sy, bx, by)
// Embedded shaders
#include "shaders/no_skinning.vert_inc.hh"
#include "shaders/normals.frag_inc.hh"
#include "shaders/usdpreviewsurface.frag_inc.hh"
#include "shaders/world_fragment.frag_inc.hh"
#define CHECK_GL(tag) \
do { \
GLenum err = glGetError(); \
if (err != GL_NO_ERROR) { \
std::cerr << "[" << tag << "] " << __FILE__ << ":" << __LINE__ << ":" \
<< __func__ << " code " << std::to_string(int(err)) << "\n"; \
} \
} while (0)
struct GLTexParams {
// std::map<std::string, GLint> uniforms;
GLenum wrapS{GL_REPEAT};
GLenum wrapT{GL_REPEAT};
std::array<float, 4> borderCol{0.0f, 0.0f, 0.0f, 0.0f}; // transparent black
// Use 3x3 mat to support pivot transform.
tinyusdz::tydra::mat3 uv_transform{tinyusdz::tydra::mat3::identity()};
};
struct GLTexState {
GLTexParams texParams;
std::string sampler_name;
uint32_t slot_id{0};
GLuint tex_id; // glBindTexture id
GLint u_tex{-1}; // sampler glUniform location
GLint u_transform; // texcoord transform
};
template <typename T>
struct GLTexOrFactor {
GLTexOrFactor(const T &v) : factor(v) {}
GLTexState tex;
T factor;
GLint u_factor{-1};
};
template <typename T>
struct GLUniformFactor {
GLUniformFactor(const T &v) : factor(v) {}
T factor;
GLint u_factor{-1};
};
struct GLUsdPreviewSurfaceState {
static constexpr auto kDiffuseColor = "diffuseColor";
static constexpr auto kEmissiveColor = "emissiveColor";
static constexpr auto kSpecularColor = "specularColor";
static constexpr auto kUseSpecularWorkflow = "useSpecularWorkflow";
static constexpr auto kMetallic = "metallic";
static constexpr auto kRoughness = "roughness";
static constexpr auto kClearcoat = "clearcoat";
static constexpr auto kClearcoatRoughness = "clearcoatRoughness";
static constexpr auto kOpacity = "opacity";
static constexpr auto kOpacityThreshold = "opacityThreshold";
static constexpr auto kIor = "ior";
static constexpr auto kNormal = "normal";
static constexpr auto kOcclusion = "occlusion";
GLTexOrFactor<tinyusdz::tydra::vec3> diffuseColor{{0.18f, 0.18f, 0.18f}};
GLTexOrFactor<tinyusdz::tydra::vec3> emissiveColor{{0.0f, 0.0f, 0.0f}};
GLUniformFactor<int> useSpecularWorkflow{0}; // non-texturable
GLTexOrFactor<tinyusdz::tydra::vec3> specularColor{
{0.0f, 0.0f, 0.0f}}; // useSpecularWorkflow = 1
GLTexOrFactor<float> metallic{0.0f}; // useSpecularWorkflow = 0
GLTexOrFactor<float> roughness{0.5f};
GLTexOrFactor<float> clearcoat{0.0f};
GLTexOrFactor<float> clearcoatRoughness{0.01f};
GLTexOrFactor<float> opacity{1.0f};
GLTexOrFactor<float> opacityThreshold{0.0f};
GLTexOrFactor<float> ior{1.5f};
GLTexOrFactor<tinyusdz::tydra::vec3> normal{
{0.0f, 0.0f, 1.0f}}; // normal map
// No displacement mapping on OpenGL
// GLTexOrFactor<float> displacement{0.0f};
GLTexOrFactor<float> occlusion{1.0f};
};
template <typename T>
bool SetupGLUsdPreviewSurfaceParam(const GLuint prog_id,
const tinyusdz::tydra::RenderScene &scene,
const std::string &base_shadername,
const tinyusdz::tydra::ShaderParam<T> &s,
GLTexOrFactor<T> &dst) {
if (s.is_texture()) {
{
std::string u_name = base_shadername + "Tex";
GLint loc = glGetUniformLocation(prog_id, u_name.c_str());
dst.tex.u_tex = loc;
}
{
std::string u_name = base_shadername + "TexTransform";
GLint loc = glGetUniformLocation(prog_id, u_name.c_str());
dst.tex.u_transform = loc;
if (s.textureId < 0 || s.textureId >= scene.textures.size()) {
std::cerr << "Invalid txtureId for " << base_shadername + "\n";
} else {
const tinyusdz::tydra::UVTexture &uvtex =
scene.textures[size_t(s.textureId)];
dst.tex.texParams.uv_transform = uvtex.transform;
}
}
} else {
GLint loc = glGetUniformLocation(prog_id, base_shadername.c_str());
if (loc < 0) {
std::cerr << base_shadername << " uniform not found in the shader.\n";
}
dst.u_factor = loc;
dst.factor = s.value;
}
return true;
}
bool ReloadShader(GLuint prog_id, const std::string &vert_filepath,
const std::string &frag_filepath) {
std::string vert_str;
std::string frag_str;
if (vert_filepath.size() && tinyusdz::io::FileExists(vert_filepath)) {
std::vector<uint8_t> bytes;
std::string err;
if (!tinyusdz::io::ReadWholeFile(&bytes, &err, vert_filepath)) {
std::cerr << "Read vertg shader failed: " << err << "\n";
return false;
}
vert_str =
std::string(reinterpret_cast<char *>(bytes.data()), bytes.size());
std::cout << "VERT:\n" << vert_str << "\n";
}
if (frag_filepath.size() && tinyusdz::io::FileExists(frag_filepath)) {
std::vector<uint8_t> bytes;
std::string err;
if (!tinyusdz::io::ReadWholeFile(&bytes, &err, frag_filepath)) {
std::cerr << "Read frag shader failed: " << err << "\n";
return false;
}
frag_str =
std::string(reinterpret_cast<char *>(bytes.data()), bytes.size());
std::cout << "FRAG:\n" << frag_str << "\n";
}
// TODO
return true;
}
bool SetupGLUsdPreviewSurface(GLuint prog_id,
tinyusdz::tydra::RenderScene &scene,
tinyusdz::tydra::RenderMaterial &m,
GLUsdPreviewSurfaceState &dst) {
const auto surfaceShader = m.surfaceShader;
if (!SetupGLUsdPreviewSurfaceParam(
prog_id, scene, GLUsdPreviewSurfaceState::kDiffuseColor,
surfaceShader.diffuseColor, dst.diffuseColor)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(
prog_id, scene, GLUsdPreviewSurfaceState::kEmissiveColor,
surfaceShader.emissiveColor, dst.emissiveColor)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(
prog_id, scene, GLUsdPreviewSurfaceState::kSpecularColor,
surfaceShader.specularColor, dst.specularColor)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kMetallic,
surfaceShader.metallic, dst.metallic)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kRoughness,
surfaceShader.roughness, dst.roughness)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kClearcoat,
surfaceShader.clearcoat, dst.clearcoat)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(
prog_id, scene, GLUsdPreviewSurfaceState::kClearcoatRoughness,
surfaceShader.clearcoatRoughness, dst.clearcoatRoughness)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kOpacity,
surfaceShader.opacity, dst.opacity)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(
prog_id, scene, GLUsdPreviewSurfaceState::kOpacityThreshold,
surfaceShader.opacityThreshold, dst.opacityThreshold)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kIor,
surfaceShader.ior, dst.ior)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kOcclusion,
surfaceShader.occlusion, dst.occlusion)) {
return false;
}
if (!SetupGLUsdPreviewSurfaceParam(prog_id, scene,
GLUsdPreviewSurfaceState::kNormal,
surfaceShader.normal, dst.normal)) {
return false;
}
{
GLint loc = glGetUniformLocation(
prog_id, GLUsdPreviewSurfaceState::kUseSpecularWorkflow);
if (loc < 0) {
std::cerr << GLUsdPreviewSurfaceState::kUseSpecularWorkflow
<< " uniform not found in the shader.\n";
}
dst.useSpecularWorkflow.factor =
surfaceShader.useSpecularWorkFlow ? 1.0f : 0.0f;
dst.useSpecularWorkflow.u_factor = loc;
}
// TODO: `displacement` param
return true;
}
struct GLVertexUniformState {
GLint u_model{-1};
GLint u_normal{-1};
GLint u_mvp{-1};
std::array<float, 16> modelMatrix[16];
std::array<float, 9> normalMatrix[9]; // 3x3 transpose(inverse(model * view))
std::array<float, 16> mvp[16]; // modeviewprojection
};
// TODO: Use handle_id for key
struct GLMeshState {
std::map<std::string, GLint> attribs;
std::vector<GLuint> diffuseTexHandles;
GLuint vertex_array_object{0}; // vertex array object
GLuint num_triangles{0}; // up to 4GB triangles
};
struct GLNodeState {
GLVertexUniformState gl_v_uniform_state;
GLMeshState gl_mesh_state;
GLTexState gl_tex_state;
};
struct GLProgramState {
// std::map<std::string, GLint> uniforms;
std::map<std::string, example::shader> shaders;
};
struct GLScene {
std::vector<GLNodeState> gl_nodes;
// scene bounding box
std::array<float, 3> bmin;
std::array<float, 3> bmax;
};
struct GUIContext {
enum AOV {
AOV_COLOR = 0,
AOV_NORMAL,
AOV_POSITION,
AOV_DEPTH,
AOV_TEXCOORD,
AOV_VARYCOORD,
AOV_VERTEXCOLOR
};
AOV aov{AOV_COLOR};
int width = 1024;
int height = 768;
int mouse_x = -1;
int mouse_y = -1;
bool mouse_left_down = false;
bool shift_pressed = false;
bool ctrl_pressed = false;
bool tab_pressed = false;
float curr_quat[4] = {0.0f, 0.0f, 0.0f, 1.0f};
float prev_quat[4] = {0.0f, 0.0f, 0.0f, 1.0f};
float xrotate = 0.0f; // in degree
float yrotate = 0.0f; // in degree
float fov = 45.0f; // in degree
float znear = 0.01f;
float zfar = 1000.0f;
std::array<float, 3> eye = {0.0f, 0.5f, -5.0f};
std::array<float, 3> lookat = {0.0f, 0.0f, 0.0f};
std::array<float, 3> up = {0.0f, 1.0f, 0.0f};
example::Camera camera;
GLUsdPreviewSurfaceState *selected_surfaceShader{nullptr};
std::vector<GLUsdPreviewSurfaceState> surfaceShaders;
// for ImGui
std::vector<std::string> surfaceShaderNames;
std::string selected_surfaceShaderName;
std::string usd_filepath;
std::string converter_info;
std::string converter_warn;
std::string vert_filename{"../shaders/no_skinning.vert"};
std::string frag_filename{"../shaders/usdpreviewsurface.frag"};
};
GUIContext gCtx;
//
// Combo with std::vector<std::string>
//
static bool ImGuiComboUI(const std::string &caption, std::string &current_item,
const std::vector<std::string> &items) {
bool changed = false;
if (ImGui::BeginCombo(caption.c_str(), current_item.c_str())) {
for (int n = 0; n < items.size(); n++) {
bool is_selected = (current_item == items[n]);
if (ImGui::Selectable(items[n].c_str(), is_selected)) {
current_item = items[n];
changed = true;
}
if (is_selected) {
// Set the initial focus when opening the combo (scrolling + for
// keyboard navigation support in the upcoming navigation branch)
ImGui::SetItemDefaultFocus();
}
}
ImGui::EndCombo();
}
return changed;
}
static void MaterialUI()
{
ImGui::Begin("Material");
ImGuiComboUI("surfaceShader", gCtx.selected_surfaceShaderName, gCtx.surfaceShaderNames);
ImGui::End();
}
static void UsdPreviewSurfaceParamUI(
GLUsdPreviewSurfaceState &state)
{
bool changed = false;
ImGui::Begin("Shader param");
changed |= ImGui::ColorEdit3("diffuseColor", &state.diffuseColor.factor[0]);
changed |= ImGui::ColorEdit3("emissiveColor", &state.emissiveColor.factor[0]);
bool specWorkflow = state.useSpecularWorkflow.factor > 0 ? true : false;
changed |= ImGui::Checkbox("useSpecularWorkflow", &specWorkflow);
state.useSpecularWorkflow.factor = specWorkflow;
if (specWorkflow) {
changed |= ImGui::ColorEdit3("specularColor", &state.specularColor.factor[0]);
} else {
changed |= ImGui::SliderFloat("metallic", &state.metallic.factor, 0.0f, 1.0f);
}
changed |= ImGui::SliderFloat("clearcoat", &state.clearcoat.factor, 0.0f, 1.0f);
changed |= ImGui::SliderFloat("clearcoatRoughness", &state.clearcoatRoughness.factor, 0.0f, 1.0f);
changed |= ImGui::SliderFloat("opacity", &state.opacity.factor, 0.0f, 1.0f);
changed |= ImGui::SliderFloat("opacityThreshold", &state.opacityThreshold.factor, 0.0f, 1.0f);
changed |= ImGui::SliderFloat("ior", &state.ior.factor, 0.0f, 6.0f);
changed |= ImGui::SliderFloat("occlusion", &state.occlusion.factor, 0.0f, 1.0f);
ImGui::End();
}
// --- glfw ----------------------------------------------------
static void error_callback(int error, const char *description) {
std::cerr << "GLFW Error : " << error << ", " << description << std::endl;
}
static void key_callback(GLFWwindow *window, int key, int scancode, int action,
int mods) {
(void)scancode;
ImGuiIO &io = ImGui::GetIO();
if (io.WantCaptureKeyboard) {
return;
}
if ((key == GLFW_KEY_LEFT_SHIFT) || (key == GLFW_KEY_RIGHT_SHIFT)) {
auto *param =
reinterpret_cast<GUIContext *>(glfwGetWindowUserPointer(window));
param->shift_pressed = (action == GLFW_PRESS);
}
if ((key == GLFW_KEY_LEFT_CONTROL) || (key == GLFW_KEY_RIGHT_CONTROL)) {
auto *param =
reinterpret_cast<GUIContext *>(glfwGetWindowUserPointer(window));
param->ctrl_pressed = (action == GLFW_PRESS);
}
// ctrl-q
if ((key == GLFW_KEY_Q) && (action == GLFW_PRESS) &&
(mods & GLFW_MOD_CONTROL)) {
glfwSetWindowShouldClose(window, GLFW_TRUE);
}
// esc
if ((key == GLFW_KEY_ESCAPE) && (action == GLFW_PRESS)) {
glfwSetWindowShouldClose(window, GLFW_TRUE);
}
}
static void mouse_move_callback(GLFWwindow *window, double x, double y) {
auto param = reinterpret_cast<GUIContext *>(glfwGetWindowUserPointer(window));
assert(param);
if (param->mouse_left_down) {
float w = static_cast<float>(param->width);
float h = static_cast<float>(param->height);
float x_offset = param->width - w;
float y_offset = param->height - h;
if (param->ctrl_pressed) {
const float dolly_scale = 0.1f;
param->eye[2] += dolly_scale * (param->mouse_y - static_cast<float>(y));
param->lookat[2] +=
dolly_scale * (param->mouse_y - static_cast<float>(y));
} else if (param->shift_pressed) {
const float trans_scale = 0.02f;
param->eye[0] += trans_scale * (param->mouse_x - static_cast<float>(x));
param->eye[1] -= trans_scale * (param->mouse_y - static_cast<float>(y));
param->lookat[0] +=
trans_scale * (param->mouse_x - static_cast<float>(x));
param->lookat[1] -=
trans_scale * (param->mouse_y - static_cast<float>(y));
} else {
#if 0
// Adjust y.
trackball(param->prev_quat,
(2.f * (param->mouse_x - x_offset) - w) / static_cast<float>(w),
(h - 2.f * (param->mouse_y - y_offset)) / static_cast<float>(h),
(2.f * (static_cast<float>(x) - x_offset) - w) /
static_cast<float>(w),
(h - 2.f * (static_cast<float>(y) - y_offset)) /
static_cast<float>(h));
add_quats(param->prev_quat, param->curr_quat, param->curr_quat);
#else
const float rotation_amp = 1.0f;
param->xrotate += rotation_amp * (param->mouse_y - static_cast<float>(y));
param->yrotate += rotation_amp * (param->mouse_x - static_cast<float>(x));
// limit rotation around X axis.
if (param->xrotate < -89) {
param->xrotate = -89;
}
if (param->xrotate > 89) {
param->xrotate = 89;
}
#endif
}
}
param->mouse_x = static_cast<int>(x);
param->mouse_y = static_cast<int>(y);
}
static void mouse_button_callback(GLFWwindow *window, int button, int action,
int mods) {
ImGuiIO &io = ImGui::GetIO();
if (io.WantCaptureMouse || io.WantCaptureKeyboard) {
return;
}
auto param = reinterpret_cast<GUIContext *>(glfwGetWindowUserPointer(window));
assert(param);
// left button
if (button == 0) {
if (action) {
param->mouse_left_down = true;
trackball(param->prev_quat, 0.0f, 0.0f, 0.0f, 0.0f);
} else {
param->mouse_left_down = false;
}
}
}
static void resize_callback(GLFWwindow *window, int width, int height) {
auto param = reinterpret_cast<GUIContext *>(glfwGetWindowUserPointer(window));
assert(param);
param->width = width;
param->height = height;
}
// ------------------------------------------------
namespace {
void SetupVertexUniforms(GLVertexUniformState &gl_state,
const tinyusdz::value::matrix4d &worldmatd,
const tinyusdz::value::matrix4f &viewproj) {
using namespace tinyusdz::value;
// implicitly casts matrix4d to matrix4f;
matrix4f worldmat = worldmatd;
matrix4d invtransmatd =
tinyusdz::inverse(tinyusdz::upper_left_3x3_only(worldmatd));
matrix3d invtransmat33d = tinyusdz::to_matrix3x3(invtransmatd);
matrix3f invtransmat33 = invtransmat33d;
memcpy(gl_state.modelMatrix, &worldmat.m[0][0], sizeof(float) * 16);
memcpy(gl_state.normalMatrix, &invtransmat33.m[0][0], sizeof(float) * 9);
// NOTE: USD uses pre-multiply matmul
matrix4f mvp = viewproj * worldmat;
// FIXME:
memcpy(gl_state.mvp, &mvp.m[0][0], sizeof(float) * 16);
}
void SetVertexUniforms(const GLVertexUniformState &gl_state) {
if (gl_state.u_model > -1) {
glUniformMatrix4fv(gl_state.u_model, 1, GL_FALSE,
gl_state.modelMatrix->data());
CHECK_GL("UniformMatrix u_modelview");
}
if (gl_state.u_normal > -1) {
glUniformMatrix3fv(gl_state.u_normal, 1, GL_FALSE,
gl_state.normalMatrix->data());
CHECK_GL("UniformMatrix u_normal");
}
if (gl_state.u_mvp > -1) {
glUniformMatrix4fv(gl_state.u_mvp, 1, GL_FALSE, gl_state.mvp->data());
CHECK_GL("UniformMatrix u_mvp");
}
}
void SetTexUniforms(const GLuint prog_id, const GLTexState &gl_tex) {
glActiveTexture(GL_TEXTURE0 + gl_tex.slot_id);
glBindTexture(GL_TEXTURE_2D, gl_tex.tex_id);
GLint loc = glGetUniformLocation(prog_id, gl_tex.sampler_name.c_str());
if (loc > -1) {
glUniform1i(loc, gl_tex.slot_id);
}
CHECK_GL("glUniform1i u_modelview");
}
bool LoadShaders(GLProgramState &gl_state) {
// default = show normal vector as color.
std::string vert_str(reinterpret_cast<char *>(shaders_no_skinning_vert),
shaders_no_skinning_vert_len);
std::string frag_str(reinterpret_cast<char *>(shaders_usdpreviewsurface_frag),
shaders_usdpreviewsurface_frag_len);
example::shader default_shader("default", vert_str, frag_str);
gl_state.shaders["default"] = std::move(default_shader);
return true;
}
bool SetupGLUniforms(GLuint prog_id, GLVertexUniformState &gl_v_uniform_state) {
GLint model_loc = glGetUniformLocation(prog_id, kUniformModelMatrix);
if (model_loc < 0) {
std::cerr << kUniformModelMatrix << " not found in the vertex shader.\n";
// return false;
} else {
gl_v_uniform_state.u_model = model_loc;
}
GLint norm_loc = glGetUniformLocation(prog_id, kUniformNormalMatrix);
if (norm_loc < 0) {
std::cerr << kUniformNormalMatrix << " not found in the vertex shader.\n";
// return false;
} else {
gl_v_uniform_state.u_normal = norm_loc;
}
GLint mvp_loc = glGetUniformLocation(prog_id, kUniformMVPMatrix);
if (mvp_loc < 0) {
std::cerr << kUniformMVPMatrix << " not found in the vertex shader.\n";
// return false;
} else {
gl_v_uniform_state.u_mvp = mvp_loc;
}
return true;
}
bool SetupTexture(const tinyusdz::tydra::RenderScene &scene,
tinyusdz::tydra::UVTexture &tex) {
auto glwrapmode = [](const tinyusdz::tydra::UVTexture::WrapMode mode) {
if (mode == tinyusdz::tydra::UVTexture::WrapMode::CLAMP_TO_EDGE) {
return GL_CLAMP_TO_EDGE;
} else if (mode == tinyusdz::tydra::UVTexture::WrapMode::REPEAT) {
return GL_REPEAT;
} else if (mode == tinyusdz::tydra::UVTexture::WrapMode::MIRROR) {
return GL_MIRRORED_REPEAT;
} else if (mode == tinyusdz::tydra::UVTexture::WrapMode::CLAMP_TO_BORDER) {
return GL_CLAMP_TO_BORDER;
}
// Just in case: Fallback to REPEAT
return GL_REPEAT;
};
GLTexState texState;
GLTexParams texParams;
texParams.wrapS = glwrapmode(tex.wrapS);
texParams.wrapT = glwrapmode(tex.wrapT);
GLuint texid{0};
glGenTextures(1, &texid);
glBindTexture(GL_TEXTURE_2D, texid);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texParams.wrapS);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texParams.wrapT);
// Transparent black For `black` wrap mode.
// https://github.com/PixarAnimationStudios/OpenUSD/commit/2cf6612b2b1d5a1a1031bc153867116c5963e605
texParams.borderCol = {0.0f, 0.0f, 0.0f, 0.0f};
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR,
&texParams.borderCol[0]);
CHECK_GL("texture_id[" << std::to_string(tex.texture_image_id)
<< "] glTexParameters");
texState.texParams = std::move(texParams);
int64_t image_id = tex.texture_image_id;
if (image_id >= 0) {
if (image_id < scene.images.size()) {
const tinyusdz::tydra::TextureImage &image =
scene.images[size_t(image_id)];
if ((image.width < 1) || (image.height < 1) || (image.channels < 1)) {
std::cerr << "Texture image is not loaded(texture file not found?).\n";
glBindTexture(GL_TEXTURE_2D, 0);
return false;
}
uint32_t bytesperpixel = 1;
GLenum format{GL_LUMINANCE};
if (image.channels == 1) {
format = GL_LUMINANCE;
bytesperpixel = 1;
} else if (image.channels == 2) {
format = GL_LUMINANCE_ALPHA;
bytesperpixel = 2;
} else if (image.channels == 3) {
format = GL_RGB;
bytesperpixel = 3;
} else if (image.channels == 4) {
format = GL_RGBA;
bytesperpixel = 4;
}
GLenum type{GL_BYTE};
if (image.texelComponentType == tinyusdz::tydra::ComponentType::UInt8) {
type = GL_BYTE;
bytesperpixel *= 1;
} else if (image.texelComponentType ==
tinyusdz::tydra::ComponentType::Half) {
type = GL_SHORT;
bytesperpixel *= 2;
} else if (image.texelComponentType ==
tinyusdz::tydra::ComponentType::UInt32) {
type = GL_UNSIGNED_INT;
bytesperpixel *= 4;
} else if (image.texelComponentType ==
tinyusdz::tydra::ComponentType::Float) {
type = GL_FLOAT;
bytesperpixel *= 4;
} else {
std::cout << "Unsupported texelComponentType: "
<< tinyusdz::tydra::to_string(image.texelComponentType)
<< "\n";
}
int64_t buffer_id = image.buffer_id;
if ((buffer_id >= 0) && (buffer_id < scene.buffers.size())) {
const tinyusdz::tydra::BufferData &buffer =
scene.buffers[size_t(buffer_id)];
// byte length check.
if (size_t(image.width) * size_t(image.height) * size_t(bytesperpixel) >
buffer.data.size()) {
std::cerr << "Insufficient texel data. : "
<< "width: " << image.width << ", height " << image.height
<< ", bytesperpixel " << bytesperpixel
<< ", requested bytes: "
<< size_t(image.width) * size_t(image.height) *
size_t(bytesperpixel)
<< ", buffer bytes: " << std::to_string(buffer.data.size())
<< "\n";
// continue anyway
} else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
format, type, buffer.data.data());
CHECK_GL("texture_id[" << std::to_string(image_id)
<< "] glTexImage2D");
}
}
}
}
tex.handle = texid;
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
static void BuildFacevaryingGeometricNormals(
const std::vector<tinyusdz::tydra::vec3> &points,
std::vector<tinyusdz::tydra::vec3> &geom_facevarying_normals);
static bool SetupMesh(const tinyusdz::Axis &stageUpAxis,
const tinyusdz::tydra::RenderMesh &mesh,
GLuint program_id,
GLMeshState &gl_state) // [out]
{
std::cout << "program_id " << program_id << "\n";
std::vector<uint32_t> indices;
if (mesh.faceVertexCounts.empty()) {
// assume all triangulaged faces.
if ((mesh.faceVertexIndices.size() % 3) != 0) {
std::cerr << "mesh <" << mesh.abs_name << "> faceVertexIndices.size "
<< std::to_string(mesh.faceVertexIndices.size())
<< " must be multiple of 3\n";
}
for (size_t f = 0; f < mesh.faceVertexIndices.size() / 3; f++) {
for (size_t c = 0; c < 3; c++) {
indices.push_back(mesh.faceVertexIndices[3 * f + c]);
}
}
} else {
size_t faceVertexIndexOffset = 0;
// Currently all faces must be triangle.
for (size_t f = 0; f < mesh.faceVertexCounts.size(); f++) {
if (mesh.faceVertexCounts[f] != 3) {
std::cerr << "mesh <" << mesh.abs_name
<< "> Non triangle face found at faceVertexCounts[" << f
<< "] (" << mesh.faceVertexCounts[f] << ")\n";
return false;
}
size_t fvCounts = mesh.faceVertexCounts[f];
for (size_t c = 0; c < fvCounts; c++) {
indices.push_back(mesh.faceVertexIndices[faceVertexIndexOffset + c]);
}
faceVertexIndexOffset += fvCounts;
}
}
glGenVertexArrays(1, &gl_state.vertex_array_object);
CHECK_GL(mesh.abs_name << "GenVertexArrays");
glBindVertexArray(gl_state.vertex_array_object);
CHECK_GL(mesh.abs_name << "BindVertexArray");
//
// Current settings
// - position
// - normals
// - texcoords0
//
// all vertex attribs are represented as facevarying data.
//
// - Static mesh(STATIC_DRAW) only
std::vector<tinyusdz::tydra::vec3> facevaryingVertices;
{ // position
// expand position to facevarying data.
// assume faces are all triangle.
gl_state.num_triangles = indices.size() / 3;
for (size_t i = 0; i < indices.size() / 3; i++) {
size_t vi0 = indices[3 * i + 0];
size_t vi1 = indices[3 * i + 1];
size_t vi2 = indices[3 * i + 2];
if (vi0 >= mesh.points.size()) {
std::cerr << "indices[" << (3 * i + 0) << "(" << vi0
<< ") exceeds mesh.points.size()(" << mesh.points.size()
<< ")\n";
return false;
}
if (vi1 >= mesh.points.size()) {
std::cerr << "indices[" << (3 * i + 1) << "(" << vi1
<< ") exceeds mesh.points.size()(" << mesh.points.size()
<< ")\n";
return false;
}
if (vi2 >= mesh.points.size()) {
std::cerr << "indices[" << (3 * i + 2) << "(" << vi2
<< ") exceeds mesh.points.size()(" << mesh.points.size()
<< ")\n";
return false;
}
if (stageUpAxis == tinyusdz::Axis::Z) {
tinyusdz::tydra::vec3 p0;
p0[0] = mesh.points[vi0][0];
p0[1] = mesh.points[vi0][2];
p0[2] = mesh.points[vi0][1];
tinyusdz::tydra::vec3 p1;
p1[0] = mesh.points[vi1][0];
p1[1] = mesh.points[vi1][2];
p1[2] = mesh.points[vi1][1];
tinyusdz::tydra::vec3 p2;
p2[0] = mesh.points[vi2][0];
p2[1] = mesh.points[vi2][2];
p2[2] = mesh.points[vi2][1];
facevaryingVertices.push_back(p0);
facevaryingVertices.push_back(p1);
facevaryingVertices.push_back(p2);
} else {
// TODO: upAxis X
facevaryingVertices.push_back(mesh.points[vi0]);
facevaryingVertices.push_back(mesh.points[vi1]);
facevaryingVertices.push_back(mesh.points[vi2]);
}
}
GLuint vb;
glGenBuffers(1, &vb);
glBindBuffer(GL_ARRAY_BUFFER, vb);
glBufferData(GL_ARRAY_BUFFER,
facevaryingVertices.size() * sizeof(tinyusdz::tydra::vec3),
facevaryingVertices.data(), GL_STATIC_DRAW);
CHECK_GL("Set facevaryingVertices buffer data");
GLint loc = glGetAttribLocation(program_id, kAttribPoints);
if (loc > -1) {
glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE,
/* stride */ sizeof(GLfloat) * 3, 0);
CHECK_GL("VertexAttribPointer");
} else {
std::cerr << "vertex positions: " << kAttribPoints
<< " attribute not found in vertex shader.\n";
return false;
}
}
std::vector<tinyusdz::tydra::vec3> facevaryingNormals;
if (mesh.facevaryingNormals.size()) {
facevaryingNormals = mesh.facevaryingNormals;
} else {
BuildFacevaryingGeometricNormals(facevaryingVertices, facevaryingNormals);
}
if (facevaryingNormals.size()) { // normals
GLuint vb;
glGenBuffers(1, &vb);
glBindBuffer(GL_ARRAY_BUFFER, vb);
glBufferData(GL_ARRAY_BUFFER,
mesh.facevaryingNormals.size() * sizeof(tinyusdz::tydra::vec3),
mesh.facevaryingNormals.data(), GL_STATIC_DRAW);
CHECK_GL("Set facevaryingNormals buffer data");
GLint loc = glGetAttribLocation(program_id, kAttribNormals);
if (loc > -1) {
glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE,
/* stride */ sizeof(GLfloat) * 3, 0);
CHECK_GL("VertexAttribPointer");
} else {
std::cerr
<< "vertex normals: " << kAttribNormals
<< " attribute not found in vertex shader. Shader does not use it?\n";
// may ok
}
}
// texcoords0 only
// TODO: multi texcoords
if (mesh.facevaryingTexcoords.size() == 1) {
for (const auto it : mesh.facevaryingTexcoords) {
uint32_t slot_id = it.first;
if (slot_id >= kMaxTexCoords) {
std::cerr << "Texcoord slot id " << slot_id
<< " must be less than kMaxTexCoords " << kMaxTexCoords
<< "\n";
return false;
}
GLuint vb;
glGenBuffers(1, &vb);
glBindBuffer(GL_ARRAY_BUFFER, vb);
glBufferData(GL_ARRAY_BUFFER,
it.second.size() * sizeof(tinyusdz::tydra::vec2),
it.second.data(), GL_STATIC_DRAW);
CHECK_GL("Set facevaryingTexcoord0 buffer data");
std::string texattr = kAttribTexCoordBase + std::to_string(slot_id);
GLint loc = glGetAttribLocation(program_id, texattr.c_str());
if (loc > -1) {
glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE,
/* stride */ sizeof(GLfloat) * 2, 0);
CHECK_GL("VertexAttribPointer");
} else {
std::cerr << "Texture UV0: " << texattr
<< " attribute not found in vertex shader.\n";
// may OK
}
}
}
// We build facevarying vertex data, so no index buffers.
#if 0
// Build index buffer.
GLuint elementbuffer;
glGenBuffers(1, &elementbuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementbuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
CHECK_GL(mesh.abs_name << "ElementArrayBuffer");
#endif
glBindVertexArray(0);
CHECK_GL(mesh.abs_name << "UnBind VAO");
return true;
}
static void DrawMesh(const GLMeshState &gl_state) {
// Simply bind vertex array object and call glDrawArrays.
glBindVertexArray(gl_state.vertex_array_object);
glDrawArrays(GL_TRIANGLES, 0, gl_state.num_triangles * 3);
CHECK_GL("DrawArrays");
glBindVertexArray(0);
}
static void DrawNode(GLNodeState &gl_node,
const tinyusdz::value::matrix4f &viewproj) {
// FIXME
tinyusdz::value::matrix4d identm = tinyusdz::value::matrix4d::identity();
tinyusdz::value::double3 trans = {0.0, 0.0, 0.0};
tinyusdz::value::double3 rotate = {0.0, 0.0, 0.0};
tinyusdz::value::double3 scale = {1.0, 1.0, -1.0};
tinyusdz::value::matrix4d rotm =
tinyusdz::trs_angle_xyz(trans, rotate, scale);
tinyusdz::value::matrix4d modelm = rotm * identm;
SetupVertexUniforms(gl_node.gl_v_uniform_state, modelm, viewproj);
SetVertexUniforms(gl_node.gl_v_uniform_state);
// SetTexUniforms(gl_node.gl_tex_state);
DrawMesh(gl_node.gl_mesh_state);
}
static void ConvertMatrix(example::mat4 &m, tinyusdz::value::matrix4f &dst) {
for (size_t i = 0; i < 4; i++) {
for (size_t j = 0; j < 4; j++) {
dst.m[i][j] = m[i][j];
}
}
}
static void DrawScene(const example::shader &shader, GLScene &scene) {
//
// Use single shader for the scene
//
tinyusdz::value::matrix4f view;
ConvertMatrix(gCtx.camera.matrices.view, view);
tinyusdz::value::matrix4f proj;
ConvertMatrix(gCtx.camera.matrices.perspective, proj);
tinyusdz::value::matrix4f viewproj = view * proj;
// bind program
shader.use();
CHECK_GL("shader.use");
for (size_t i = 0; i < scene.gl_nodes.size(); i++) {
auto &gl_node = scene.gl_nodes[i];
DrawNode(gl_node, viewproj);
}
glUseProgram(0);
CHECK_GL("glUseProgram(0)");
}
static void ComputeBoundingBox(const tinyusdz::tydra::RenderMesh &mesh,
std::array<float, 3> &bmin,
std::array<float, 3> &bmax) {
bmin = {std::numeric_limits<float>::infinity(),
std::numeric_limits<float>::infinity(),
std::numeric_limits<float>::infinity()};
bmax = {-std::numeric_limits<float>::infinity(),
-std::numeric_limits<float>::infinity(),
-std::numeric_limits<float>::infinity()};
for (const auto &p : mesh.points) {
bmin[0] = (std::min)(bmin[0], p[0]);
bmin[1] = (std::min)(bmin[1], p[1]);
bmin[2] = (std::min)(bmin[2], p[2]);
bmax[0] = (std::max)(bmax[0], p[0]);
bmax[1] = (std::max)(bmax[1], p[1]);
bmax[2] = (std::max)(bmax[2], p[2]);
}
}
static bool ProcScene(const example::shader &gl_shader,
const tinyusdz::Stage &stage,
std::string &asset_search_path, GLScene *scene) {
tinyusdz::Axis upAxis{tinyusdz::Axis::Y};
if (stage.metas().upAxis.authored()) {
upAxis = stage.metas().upAxis.get_value();
}
std::cout << "upAxis " << tinyusdz::to_string(upAxis) << "\n";
//
// Stage to Renderable Scene
//
tinyusdz::tydra::RenderSceneConverter converter;
converter.set_search_paths({asset_search_path});
tinyusdz::tydra::RenderScene renderScene;
bool ret = converter.ConvertToRenderScene(stage, &renderScene);
if (converter.GetWarning().size()) {
std::cout << "ConvertToRenderScene WARN: " << converter.GetWarning()
<< "\n";
gCtx.converter_warn = converter.GetWarning();
}
if (!ret) {
std::cerr << "Failed to convert USD Stage to OpenGL-like data structure: "
<< converter.GetError() << "\n";
exit(-1);
}
std::cout << "# of meshes: " << renderScene.meshes.size() << "\n";
std::cout << "# of textures: " << renderScene.textures.size() << "\n";
gCtx.converter_info = converter.GetInfo();
std::array<float, 3> scene_bmin;
std::array<float, 3> scene_bmax;
scene_bmin = {std::numeric_limits<float>::infinity(),
std::numeric_limits<float>::infinity(),
std::numeric_limits<float>::infinity()};
scene_bmax = {-std::numeric_limits<float>::infinity(),
-std::numeric_limits<float>::infinity(),
-std::numeric_limits<float>::infinity()};
tinyusdz::value::matrix4f view;
ConvertMatrix(gCtx.camera.matrices.view, view);
tinyusdz::value::matrix4f proj;
ConvertMatrix(gCtx.camera.matrices.perspective, proj);
tinyusdz::value::matrix4f viewproj = proj * view;
std::map<std::string, GLTexState> gl_tex_state_map;
for (size_t i = 0; i < renderScene.textures.size(); i++) {
SetupTexture(renderScene, renderScene.textures[i]);
}
// TODO: Material
for (size_t i = 0; i < renderScene.meshes.size(); i++) {
std::array<float, 3> bmin;
std::array<float, 3> bmax;
ComputeBoundingBox(renderScene.meshes[i], bmin, bmax);
std::cout << "mesh[" << i << "].bmin " << bmin[0] << ", " << bmin[1] << ", "
<< bmin[2] << "\n";
std::cout << "mesh[" << i << "].bmax " << bmax[0] << ", " << bmax[1] << ", "
<< bmax[2] << "\n";
// TODO: accounnt for xform
scene_bmin[0] = (std::min)(bmin[0], scene_bmin[0]);
scene_bmin[1] = (std::min)(bmin[1], scene_bmin[1]);
scene_bmin[2] = (std::min)(bmin[2], scene_bmin[2]);
scene_bmax[0] = (std::max)(bmax[0], scene_bmax[0]);
scene_bmax[1] = (std::max)(bmax[1], scene_bmax[1]);
scene_bmax[2] = (std::max)(bmax[2], scene_bmax[2]);
GLMeshState gl_mesh;
if (!SetupMesh(upAxis, renderScene.meshes[i], gl_shader.get_program(),
gl_mesh)) {
std::cerr << "SetupMesh for mesh[" << i << "] failed.\n";
exit(-1);
}
GLNodeState gl_node;
gl_node.gl_mesh_state = gl_mesh;
// FIXME:
tinyusdz::value::double3 scene_center;
scene_center[0] = scene_bmin[0] + 0.5 * (scene_bmax[0] - scene_bmin[0]);
scene_center[1] = scene_bmin[1] + 0.5 * (scene_bmax[1] - scene_bmin[1]);
scene_center[2] = scene_bmin[2] + 0.5 * (scene_bmax[2] - scene_bmin[2]);
// FIXME
tinyusdz::value::matrix4d identm = tinyusdz::value::matrix4d::identity();
tinyusdz::value::double3 trans = {scene_center[0], scene_center[1],
scene_center[2]};
tinyusdz::value::double3 rotate = {0.0, 0.0, 0.0};
tinyusdz::value::double3 scale = {1.0, 1.0, -1.0};
tinyusdz::value::matrix4d rotm =
tinyusdz::trs_angle_xyz(trans, rotate, scale);
tinyusdz::value::matrix4d modelm = rotm * identm;
std::cout << "global matrix: " << identm << "\n";
SetupVertexUniforms(gl_node.gl_v_uniform_state, modelm, viewproj);
SetupGLUniforms(gl_shader.get_program(), gl_node.gl_v_uniform_state);
scene->gl_nodes.emplace_back(gl_node);
}
scene->bmin = scene_bmin;
scene->bmax = scene_bmax;
// TODO
return true;
}
static void vnormalize(float v[3]) {
float r;
r = std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
if (r == 0.0) return;
v[0] /= r;
v[1] /= r;
v[2] /= r;
}
static void vcross(float v1[3], float v2[3], float result[3]) {
result[0] = v1[1] * v2[2] - v1[2] * v2[1];
result[1] = v1[2] * v2[0] - v1[0] * v2[2];
result[2] = v1[0] * v2[1] - v1[1] * v2[0];
}
// based on mesa.
static void MygluLookAt(float eye[3], float center[3], float up[3]) {
float forward[3], side[3];
GLfloat m[4][4];
forward[0] = center[0] - eye[0];
forward[1] = center[1] - eye[1];
forward[2] = center[2] - eye[2];
vnormalize(forward);
/* Side = forward x up */
vcross(forward, up, side);
vnormalize(side);
/* Recompute up as: up = side x forward */
vcross(side, forward, up);
memset(m, 0, sizeof(GLfloat) * 16);
m[0][0] = 1.0f;
m[1][1] = 1.0f;
m[2][2] = 1.0f;
m[3][3] = 1.0f;
m[0][0] = side[0];
m[1][0] = side[1];
m[2][0] = side[2];
m[0][1] = up[0];
m[1][1] = up[1];
m[2][1] = up[2];
m[0][2] = -forward[0];
m[1][2] = -forward[1];
m[2][2] = -forward[2];
glMultMatrixf(&m[0][0]);
// TODO: Use glTranslated?
glTranslatef(-eye[0], -eye[1], -eye[2]);
}
std::string find_file(const std::string basefile, int max_parents = 8) {
if (max_parents > 16) {
return std::string();
}
std::string filepath = basefile;
for (size_t i = 0; i < max_parents; i++) {
if (tinyusdz::io::FileExists(filepath)) {
return filepath;
}
filepath = "../" + filepath;
}
return std::string();
}
static void BuildFacevaryingGeometricNormals(
const std::vector<tinyusdz::tydra::vec3> &points,
std::vector<tinyusdz::tydra::vec3> &geom_facevarying_normals) {
if ((points.size() % 3) != 0) {
return;
}
size_t npoints = points.size() / 3;
for (size_t i = 0; i < npoints; i++) {
tinyusdz::value::point3f p0;
p0.x = points[3 * i + 0][0];
p0.y = points[3 * i + 0][1];
p0.z = points[3 * i + 0][2];
tinyusdz::value::point3f p1;
p1.x = points[3 * i + 1][0];
p1.y = points[3 * i + 1][1];
p1.z = points[3 * i + 1][2];
tinyusdz::value::point3f p2;
p2.x = points[3 * i + 2][0];
p2.y = points[3 * i + 2][1];
p2.z = points[3 * i + 2][2];
tinyusdz::value::point3f p10 = p1 - p0;
tinyusdz::value::point3f p20 = p2 - p0;
// CCW
tinyusdz::value::point3f Ng = tinyusdz::vcross(p10, p20);
Ng = tinyusdz::vnormalize(Ng);
tinyusdz::tydra::vec3 nf;
nf[0] = Ng.x;
nf[1] = Ng.y;
nf[2] = Ng.z;
geom_facevarying_normals.push_back(nf);
geom_facevarying_normals.push_back(nf);
geom_facevarying_normals.push_back(nf);
}
}
static void ImMatrix4Display(const char *label, const float *m) {
static std::string labels[4];
labels[0] = std::string(label) + " m0";
labels[1] = std::string(label) + " m1";
labels[2] = std::string(label) + " m2";
labels[3] = std::string(label) + " m3";
ImGui::InputFloat4(labels[0].c_str(), const_cast<float *>(m), "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat4(labels[1].c_str(), const_cast<float *>(m + 4), "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat4(labels[2].c_str(), const_cast<float *>(m + 8), "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat4(labels[3].c_str(), const_cast<float *>(m + 12), "%.3f",
ImGuiInputTextFlags_ReadOnly);
}
static void ImMatrix3Display(const char *label, const float *m) {
static std::string labels[3];
labels[0] = std::string(label) + " m0";
labels[1] = std::string(label) + " m1";
labels[2] = std::string(label) + " m2";
ImGui::InputFloat3(labels[0].c_str(), const_cast<float *>(m), "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat3(labels[1].c_str(), const_cast<float *>(m + 3), "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat3(labels[2].c_str(), const_cast<float *>(m + 6), "%.3f",
ImGuiInputTextFlags_ReadOnly);
}
} // namespace
int main(int argc, char **argv) {
// Setup window
glfwSetErrorCallback(error_callback);
if (!glfwInit()) {
exit(EXIT_FAILURE);
}
// Decide GL+GLSL versions
#if defined(IMGUI_IMPL_OPENGL_ES2)
// GL ES 2.0 + GLSL 100
const char *glsl_version = "#version 100";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
#elif defined(__APPLE__)
// GL 3.2 + GLSL 150
const char *glsl_version = "#version 150";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac
#else
// GL 3.0 + GLSL 130
const char *glsl_version = "#version 130";
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
// glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+
// only glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // 3.0+ only
#endif
float highDPIscaleFactor = 1.0f;
float xscale=1.0f;
float yscale=1.0f;
#if defined(_WIN32) || defined(__linux__)
// if it's a HighDPI monitor, try to scale everything
GLFWmonitor *monitor = glfwGetPrimaryMonitor();
glfwGetMonitorContentScale(monitor, &xscale, &yscale);
std::cout << "monitor xscale, yscale = " << xscale << ", " << yscale << "\n";
if (xscale > 1 || yscale > 1) {
highDPIscaleFactor = xscale;
glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE);
}
#elif __APPLE__
glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE);
#endif
#ifdef _DEBUG_OPENGL
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
#endif
std::string filename = "models/suzanne.usdc";
// std::string filename = "models/texture-cat-plane.usdc";
// std::string filename = "models/texturedcube.usdc";
// std::string filename = "models/simple-plane.usdz";
#if defined(_MSC_VER)
std::cout << "cwd: " << _getcwd(nullptr, 0) << "\n";
#endif
if (argc > 1) {
filename = std::string(argv[1]);
}
std::string full_filepath = find_file(filename);
if (full_filepath.empty()) {
std::cerr << "cannot find or file not exists: " << filename << "\n";
}
std::cout << "Loading USD file " << full_filepath << "\n";
std::string warn;
std::string err;
tinyusdz::Stage stage;
bool ret = tinyusdz::LoadUSDFromFile(full_filepath, &stage, &warn, &err);
if (!warn.empty()) {
std::cerr << "WARN : " << warn << "\n";
return EXIT_FAILURE;
}
if (!err.empty()) {
std::cerr << "ERR : " << err << "\n";
return EXIT_FAILURE;
}
std::string basedir = tinyusdz::io::GetBaseDir(full_filepath);
std::cout << "basedir = " << basedir << "\n";
gCtx.usd_filepath = full_filepath;
GLFWwindow *window{nullptr};
window = glfwCreateWindow(gCtx.width, gCtx.height, "Simple USDZ GL viewer",
nullptr, nullptr);
glfwMakeContextCurrent(window);
glfwSwapInterval(1); // vsync on
if (!gladLoadGLLoader(reinterpret_cast<GLADloadproc>(glfwGetProcAddress))) {
std::cerr << "Failed to load OpenGL functions with gladLoadGL\n";
exit(EXIT_FAILURE);
}
std::cout << "OpenGL " << GLVersion.major << '.' << GLVersion.minor << '\n';
if (GLVersion.major < 2) {
std::cerr << "OpenGL 2. or later should be available." << std::endl;
exit(EXIT_FAILURE);
}
#ifdef _DEBUG_OPENGL
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(reinterpret_cast<GLDEBUGPROC>(glDebugOutput), nullptr);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr,
GL_TRUE);
#endif
GUIContext gui_ctx;
glfwSetWindowUserPointer(window, &gui_ctx);
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_move_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetFramebufferSizeCallback(window, resize_callback);
bool done = false;
ImGui::CreateContext();
ImGui::StyleColorsDark();
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL3_Init(glsl_version);
GLProgramState gl_progs;
if (!LoadShaders(gl_progs)) {
exit(-1);
}
GLScene gl_scene;
if (!ProcScene(gl_progs.shaders["default"], stage,
/* asset search path */ basedir, &gl_scene)) {
exit(-1);
}
std::cout << "scene bmin: " << gl_scene.bmin[0] << ", " << gl_scene.bmin[1]
<< ", " << gl_scene.bmin[2] << "\n";
std::cout << "scene bmax: " << gl_scene.bmax[0] << ", " << gl_scene.bmax[1]
<< ", " << gl_scene.bmax[2] << "\n";
int display_w, display_h;
ImVec4 clear_color = {0.1f, 0.18f, 0.3f, 1.0f};
{
float cxscale, cyscale;
glfwGetWindowContentScale(window, &cxscale, &cyscale);
std::cout << "xscale, yscale = " << cxscale << ", " << cyscale << "\n";
ImGuiIO &io = ImGui::GetIO();
io.DisplayFramebufferScale = {2.0f, 2.0f}; // HACK
ImFontConfig font_config;
font_config.SizePixels = 16.0f * xscale;
io.Fonts->AddFontDefault(&font_config);
}
std::array<float, 3> bmin = {-100.0f, -100.0f, -100.0f};
std::array<float, 3> bmax = {100.0f, 100.0f, 100.0f};
float maxExtent = 0.5f * (bmax[0] - bmin[0]);
if (maxExtent < 0.5f * (bmax[1] - bmin[1])) {
maxExtent = 0.5f * (bmax[1] - bmin[1]);
}
if (maxExtent < 0.5f * (bmax[2] - bmin[2])) {
maxExtent = 0.5f * (bmax[2] - bmin[2]);
}
float eye[3], lookat[3], up[3];
up[0] = 0.0f;
up[1] = 1.0f;
up[2] = 0.0f;
const example::shader &curr_shader = gl_progs.shaders["default"];
while (!done) {
glfwPollEvents();
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
ImGui::Begin("Info");
ImGui::Text("View control");
ImGui::Text("ctrl + left mouse");
ImGui::Text("shift + left mouse");
ImGui::Text("left mouse");
ImGui::End();
ImGui::Begin("Scene");
ImGui::InputText("filename", const_cast<char *>(gCtx.usd_filepath.c_str()),
gCtx.usd_filepath.size(), ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat3("scene bmin", &gl_scene.bmin[0], "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::InputFloat3("scene bmax", &gl_scene.bmax[0], "%.3f",
ImGuiInputTextFlags_ReadOnly);
ImGui::End();
ImGui::Begin("Material");
ImGui::End();
if (gCtx.selected_surfaceShader) {
UsdPreviewSurfaceParamUI(*gCtx.selected_surfaceShader);
}
ImGui::Begin("RenderScene converter log");
ImGui::InputTextMultiline("info",
const_cast<char *>(gCtx.converter_info.c_str()),
gCtx.converter_info.size(), ImVec2(800, 300),
ImGuiInputTextFlags_ReadOnly);
ImGui::InputTextMultiline("warn",
const_cast<char *>(gCtx.converter_warn.c_str()),
gCtx.converter_warn.size(), ImVec2(800, 300),
ImGuiInputTextFlags_ReadOnly);
ImGui::End();
// For developers only
ImGui::Begin("dev");
{
static bool compile_ok{true};
if (ImGui::Button("Reload shader")) {
compile_ok = ReloadShader(curr_shader.get_program(), gCtx.vert_filename,
gCtx.frag_filename);
}
if (compile_ok) {
ImGui::TextColored(ImVec4(0.3, 1.0, 0.4, 1.0), "Shader Compile OK");
} else {
ImGui::TextColored(ImVec4(1.0, 0.2, 0.1, 1.0), "Shader Compile Failed");
}
ImGui::End();
}
ImGui::Begin("Camera");
ImGui::SliderFloat("fov", &gCtx.fov, 0.0f, 178.0f);
ImGui::InputFloat("znear", &gCtx.znear);
ImGui::InputFloat("zfar", &gCtx.zfar);
ImGui::InputFloat3("eye", &gCtx.eye[0]);
ImGui::Separator();
ImGui::SliderFloat("xrot", &gCtx.xrotate, -89.9f, 89.9f);
ImGui::SliderFloat("yrot", &gCtx.yrotate, -180.0f, 180.0f);
ImGui::Separator();
if (ImGui::Button("Reset rotation")) {
gCtx.xrotate = 0.0f;
gCtx.yrotate = 0.0f;
}
ImGui::End();
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);
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float aspect = float(display_w) / float(display_h);
// view
gCtx.camera.setPosition(gCtx.eye);
gCtx.camera.setRotation({gCtx.xrotate, gCtx.yrotate, 0.0f});
gCtx.camera.setPerspective(gCtx.fov, aspect, gCtx.znear, gCtx.zfar);
ImGui::Begin("View matrix");
{
tinyusdz::value::matrix4f view;
ConvertMatrix(gCtx.camera.matrices.view, view);
tinyusdz::value::matrix4f proj;
ConvertMatrix(gCtx.camera.matrices.perspective, proj);
// example::mat4 viewproj = linalg::mul(gCtx.camera.matrices.perspective,
// gCtx.camera.matrices.view);
tinyusdz::value::matrix4f viewproj = view * proj;
ImMatrix4Display("view", &gCtx.camera.matrices.view[0][0]);
ImGui::Separator();
ImMatrix4Display("perspective", &gCtx.camera.matrices.perspective[0][0]);
ImGui::Separator();
// ImMatrix4Display("viewproj", &viewproj.x[0]);
ImMatrix4Display("viewproj", &viewproj.m[0][0]);
ImGui::End();
}
DrawScene(curr_shader, gl_scene);
#if 0
// Draw scene
if ((scene.default_root_node >= 0) && (scene.default_root_node < scene.nodes.size())) {
DrawNode(scene, scene.nodes[scene.default_root_node]);
} else {
static bool printed = false;
if (!printed) {
std::cerr << "USD scene does not contain root node. or has invalid root node ID\n";
std::cerr << " # of nodes in the scene: " << scene.nodes.size() << "\n";
std::cerr << " scene.default_root_node: " << scene.default_root_node << "\n";
printed = true;
}
}
#endif
// Imgui
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
// glFlush();
glfwSwapBuffers(window);
static int frameCount = 0;
static double currentTime = glfwGetTime();
static double previousTime = currentTime;
static char title[256];
frameCount++;
currentTime = glfwGetTime();
const auto deltaTime = currentTime - previousTime;
if (deltaTime >= 1.0) {
sprintf(title, "Simple GL USDC/USDA/USDZ viewer [%dFPS]", frameCount);
glfwSetWindowTitle(window, title);
frameCount = 0;
previousTime = currentTime;
}
done = glfwWindowShouldClose(window);
};
std::cout << "Close window\n";
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();
glfwDestroyWindow(window);
glfwTerminate();
return EXIT_SUCCESS;
}