AnimTestbed/src/main.cc

//------------------------------------------------------------------------------
//  imgui-glfw
//  Demonstrates basic integration with Dear Imgui (without custom
//  texture or custom font support).
//------------------------------------------------------------------------------

#include "imgui.h"
#define SOKOL_IMPL
#define SOKOL_GLCORE33
#include "sokol_gfx.h"
#include "sokol_time.h"
#define SOKOL_GL_IMPL
#include "util/sokol_gl.h"
#define GLFW_INCLUDE_NONE
#include <iostream>

#include "GLFW/glfw3.h"

const int Width = 1024;
const int Height = 768;
const int MaxVertices = (1 << 16);
const int MaxIndices = MaxVertices * 3;

uint64_t last_time = 0;
bool show_imgui_demo_window = false;
bool show_another_window = false;

sg_pass_action pass_action;
sg_pipeline pip;
sg_bindings bind;

typedef struct {
  ImVec2 disp_size;
} vs_params_t;

static void draw_imgui(ImDrawData*);

#define HANDMADE_MATH_IMPLEMENTATION
#define HANDMADE_MATH_NO_SSE
#include "HandmadeMath.h"
#include "camera.h"

// ozz-animation headers
#include <cmath>   // fmodf
#include <memory>  // std::unique_ptr, std::make_unique

#include "ozz/animation/runtime/animation.h"
#include "ozz/animation/runtime/local_to_model_job.h"
#include "ozz/animation/runtime/sampling_job.h"
#include "ozz/animation/runtime/skeleton.h"
#include "ozz/base/containers/vector.h"
#include "ozz/base/io/archive.h"
#include "ozz/base/io/stream.h"
#include "ozz/base/log.h"
#include "ozz/base/maths/soa_transform.h"
#include "ozz/base/maths/vec_float.h"

// wrapper struct for managed ozz-animation C++ objects, mUST BE DEleted
// before shutdown, otherwise ozz-animation will report a memory leak
typedef struct {
  ozz::animation::Skeleton skeleton;
  ozz::animation::Animation animation;
  ozz::animation::SamplingCache cache;
  ozz::vector<ozz::math::SoaTransform> local_matrices;
  ozz::vector<ozz::math::Float4x4> model_matrices;
} ozz_t;

static struct {
  std::unique_ptr<ozz_t> ozz;
  sg_pass_action pass_action;
  camera_t camera;
  struct {
    bool skeleton;
    bool animation;
    bool failed;
  } loaded;
  struct {
    double frame;
    double absolute;
    uint64_t laptime;
    float factor;
    float anim_ratio;
    bool anim_ratio_ui_override;
    bool paused;
  } time;
} state;

// io buffers for skeleton and animation data files, we know the max file size upfront
static uint8_t skel_data_buffer[4 * 1024];
static uint8_t anim_data_buffer[32 * 1024];

static void load_skeleton(void);
static void load_animation(void);
static void eval_animation(void);
static void draw_skeleton(void);
static void draw_ui(void);
// static void skeleton_data_loaded(const sfetch_response_t* response);
// static void animation_data_loaded(const sfetch_response_t* response);
static void frame(void);

int main() {
  // window and GL context via GLFW and flextGL
  glfwInit();
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE);
  GLFWwindow* w = glfwCreateWindow(Width, Height, "Sokol+ImGui+GLFW", 0, 0);
  glfwMakeContextCurrent(w);
  glfwSwapInterval(1);

  // GLFW to ImGui input forwarding
  glfwSetMouseButtonCallback(
      w,
      [](GLFWwindow*, int btn, int action, int /*mods*/) {
        if ((btn >= 0) && (btn < 3)) {
          ImGui::GetIO().MouseDown[btn] = (action == GLFW_PRESS);
        }
      });
  glfwSetCursorPosCallback(w, [](GLFWwindow*, double pos_x, double pos_y) {
    ImGui::GetIO().MousePos.x = float(pos_x);
    ImGui::GetIO().MousePos.y = float(pos_y);
  });
  glfwSetScrollCallback(w, [](GLFWwindow*, double /*pos_x*/, double pos_y) {
    ImGui::GetIO().MouseWheel = float(pos_y);
  });
  glfwSetKeyCallback(
      w,
      [](GLFWwindow*, int key, int /*scancode*/, int action, int mods) {
        ImGuiIO& io = ImGui::GetIO();
        if ((key >= 0) && (key < 512)) {
          io.KeysDown[key] = (action == GLFW_PRESS) || (action == GLFW_REPEAT);
        }
        io.KeyCtrl = (0 != (mods & GLFW_MOD_CONTROL));
        io.KeyAlt = (0 != (mods & GLFW_MOD_ALT));
        io.KeyShift = (0 != (mods & GLFW_MOD_SHIFT));
      });
  glfwSetCharCallback(w, [](GLFWwindow*, unsigned int codepoint) {
    ImGui::GetIO().AddInputCharacter((ImWchar)codepoint);
  });

  // setup sokol_gfx and sokol_time
  stm_setup();
  sg_desc desc = {};
  sg_setup(&desc);
  assert(sg_isvalid());

  // setup sokol-gl
  sgl_desc_t sgldesc = {};
  sgldesc.sample_count = 0;
  sgl_setup(&sgldesc);

  state.ozz = std::make_unique<ozz_t>();
  state.time.factor = 1.0f;

  // initialize camera helper
  camera_desc_t camdesc = {};
  camdesc.min_dist = 1.0f;
  camdesc.max_dist = 100.0f;
	camdesc.farz = 1000.0f;
  camdesc.center.Y = 1.0f;
  camdesc.distance = 30.0f;
  camdesc.latitude = 10.0f;
  camdesc.longitude = 20.0f;
  cam_init(&state.camera, &camdesc);

  // setup Dear Imgui
  ImGui::CreateContext();
  ImGui::StyleColorsDark();
  ImGuiIO& io = ImGui::GetIO();
  io.IniFilename = nullptr;
  io.Fonts->AddFontDefault();
  io.KeyMap[ImGuiKey_Tab] = GLFW_KEY_TAB;
  io.KeyMap[ImGuiKey_LeftArrow] = GLFW_KEY_LEFT;
  io.KeyMap[ImGuiKey_RightArrow] = GLFW_KEY_RIGHT;
  io.KeyMap[ImGuiKey_UpArrow] = GLFW_KEY_UP;
  io.KeyMap[ImGuiKey_DownArrow] = GLFW_KEY_DOWN;
  io.KeyMap[ImGuiKey_Home] = GLFW_KEY_HOME;
  io.KeyMap[ImGuiKey_End] = GLFW_KEY_END;
  io.KeyMap[ImGuiKey_Delete] = GLFW_KEY_DELETE;
  io.KeyMap[ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE;
  io.KeyMap[ImGuiKey_Enter] = GLFW_KEY_ENTER;
  io.KeyMap[ImGuiKey_Escape] = GLFW_KEY_ESCAPE;
  io.KeyMap[ImGuiKey_A] = GLFW_KEY_A;
  io.KeyMap[ImGuiKey_C] = GLFW_KEY_C;
  io.KeyMap[ImGuiKey_V] = GLFW_KEY_V;
  io.KeyMap[ImGuiKey_X] = GLFW_KEY_X;
  io.KeyMap[ImGuiKey_Y] = GLFW_KEY_Y;
  io.KeyMap[ImGuiKey_Z] = GLFW_KEY_Z;

  // dynamic vertex- and index-buffers for imgui-generated geometry
  sg_buffer_desc vbuf_desc = {};
  vbuf_desc.usage = SG_USAGE_STREAM;
  vbuf_desc.size = MaxVertices * sizeof(ImDrawVert);
  bind.vertex_buffers[0] = sg_make_buffer(&vbuf_desc);

  sg_buffer_desc ibuf_desc = {};
  ibuf_desc.type = SG_BUFFERTYPE_INDEXBUFFER;
  ibuf_desc.usage = SG_USAGE_STREAM;
  ibuf_desc.size = MaxIndices * sizeof(ImDrawIdx);
  bind.index_buffer = sg_make_buffer(&ibuf_desc);

  // font texture for imgui's default font
  unsigned char* font_pixels;
  int font_width, font_height;
  io.Fonts->GetTexDataAsRGBA32(&font_pixels, &font_width, &font_height);
  sg_image_desc img_desc = {};
  img_desc.width = font_width;
  img_desc.height = font_height;
  img_desc.pixel_format = SG_PIXELFORMAT_RGBA8;
  img_desc.wrap_u = SG_WRAP_CLAMP_TO_EDGE;
  img_desc.wrap_v = SG_WRAP_CLAMP_TO_EDGE;
  img_desc.data.subimage[0][0] =
      sg_range{font_pixels, size_t(font_width * font_height * 4)};
  bind.fs_images[0] = sg_make_image(&img_desc);

  // shader object for imgui rendering
  sg_shader_desc shd_desc = {};
  auto& ub = shd_desc.vs.uniform_blocks[0];
  ub.size = sizeof(vs_params_t);
  ub.uniforms[0].name = "disp_size";
  ub.uniforms[0].type = SG_UNIFORMTYPE_FLOAT2;
  shd_desc.vs.source =
      "#version 330\n"
      "uniform vec2 disp_size;\n"
      "layout(location=0) in vec2 position;\n"
      "layout(location=1) in vec2 texcoord0;\n"
      "layout(location=2) in vec4 color0;\n"
      "out vec2 uv;\n"
      "out vec4 color;\n"
      "void main() {\n"
      "    gl_Position = vec4(((position/disp_size)-0.5)*vec2(2.0,-2.0), 0.5, "
      "1.0);\n"
      "    uv = texcoord0;\n"
      "    color = color0;\n"
      "}\n";
  shd_desc.fs.images[0].name = "tex";
  shd_desc.fs.images[0].image_type = SG_IMAGETYPE_2D;
  shd_desc.fs.source =
      "#version 330\n"
      "uniform sampler2D tex;\n"
      "in vec2 uv;\n"
      "in vec4 color;\n"
      "out vec4 frag_color;\n"
      "void main() {\n"
      "    frag_color = texture(tex, uv) * color;\n"
      "}\n";
  sg_shader shd = sg_make_shader(&shd_desc);

  // pipeline object for imgui rendering
  sg_pipeline_desc pip_desc = {};
  pip_desc.layout.buffers[0].stride = sizeof(ImDrawVert);
  auto& attrs = pip_desc.layout.attrs;
  attrs[0].format = SG_VERTEXFORMAT_FLOAT2;
  attrs[1].format = SG_VERTEXFORMAT_FLOAT2;
  attrs[2].format = SG_VERTEXFORMAT_UBYTE4N;
  pip_desc.shader = shd;
  pip_desc.index_type = SG_INDEXTYPE_UINT16;
  pip_desc.colors[0].blend.enabled = true;
  pip_desc.colors[0].blend.src_factor_rgb = SG_BLENDFACTOR_SRC_ALPHA;
  pip_desc.colors[0].blend.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
  pip_desc.colors[0].write_mask = SG_COLORMASK_RGB;
  pip = sg_make_pipeline(&pip_desc);

  // initial clear color
  pass_action.colors[0].action = SG_ACTION_CLEAR;
  pass_action.colors[0].value = {0.0f, 0.5f, 0.7f, 1.0f};

  load_skeleton();
  load_animation();

  // draw loop
  while (!glfwWindowShouldClose(w)) {
    state.time.frame = stm_sec(
        stm_round_to_common_refresh_rate(stm_laptime(&state.time.laptime)));

    int cur_width, cur_height;
    glfwGetFramebufferSize(w, &cur_width, &cur_height);

    cam_update(&state.camera, cur_width, cur_height);

    // this is standard ImGui demo code
    ImGuiIO& io = ImGui::GetIO();
    io.DisplaySize = ImVec2(float(cur_width), float(cur_height));
    io.DeltaTime = (float)stm_sec(stm_laptime(&last_time));
    ImGui::NewFrame();

    if (ImGui::BeginMainMenuBar()) {
      ImGui::Text("AnimTestbed");
      ImGui::Checkbox("ImGui Demo", &show_imgui_demo_window);
      ImGui::EndMainMenuBar();
    }

    frame();
    draw_ui();

    // 3. Show the ImGui test window. Most of the sample code is in ImGui::ShowDemoWindow()
    if (show_imgui_demo_window) {
      ImGui::SetNextWindowPos(ImVec2(460, 20), ImGuiCond_FirstUseEver);
      ImGui::ShowDemoWindow();
    }

    ImGui::Begin("Camera");
    ImGui::SliderFloat("min_dist", &state.camera.min_dist, 1.0f, 100.f);
    ImGui::SliderFloat("max_dist", &state.camera.max_dist, 1.0f, 100.f);
    ImGui::SliderFloat("center.Y", &state.camera.center.Y, 1.0f, 100.f);
    ImGui::SliderFloat("distance", &state.camera.distance, 1.0f, 1000.f);
    ImGui::SliderFloat("latitude", &state.camera.latitude, 1.0f, 100.f);
    ImGui::SliderFloat("longitude", &state.camera.longitude, -179.0f, 179.f);
    ImGui::End();

    // the sokol_gfx draw pass
    sg_begin_default_pass(&pass_action, cur_width, cur_height);
    sgl_draw();
    ImGui::Render();
    draw_imgui(ImGui::GetDrawData());
    sg_end_pass();
    sg_commit();
    glfwSwapBuffers(w);
    glfwPollEvents();
  }

  state.ozz = nullptr;

  /* cleanup */
  ImGui::DestroyContext();
  sgl_shutdown();
  sg_shutdown();
  glfwTerminate();
  return 0;
}

bool LoadSkeleton(const char* _filename, ozz::animation::Skeleton* _skeleton) {
  assert(_filename && _skeleton);
  ozz::log::Out() << "Loading skeleton archive " << _filename << "."
                  << std::endl;
  ozz::io::File file(_filename, "rb");
  if (!file.opened()) {
    ozz::log::Err() << "Failed to open skeleton file " << _filename << "."
                    << std::endl;
    return false;
  }
  ozz::io::IArchive archive(&file);
  if (!archive.TestTag<ozz::animation::Skeleton>()) {
    ozz::log::Err() << "Failed to load skeleton instance from file "
                    << _filename << "." << std::endl;
    return false;
  }

  // Once the tag is validated, reading cannot fail.
  archive >> *_skeleton;

  return true;
}

bool LoadAnimation(
    const char* _filename,
    ozz::animation::Animation* _animation) {
  assert(_filename && _animation);
  ozz::log::Out() << "Loading animation archive: " << _filename << "."
                  << std::endl;
  ozz::io::File file(_filename, "rb");
  if (!file.opened()) {
    ozz::log::Err() << "Failed to open animation file " << _filename << "."
                    << std::endl;
    return false;
  }
  ozz::io::IArchive archive(&file);
  if (!archive.TestTag<ozz::animation::Animation>()) {
    ozz::log::Err() << "Failed to load animation instance from file "
                    << _filename << "." << std::endl;
    return false;
  }

  // Once the tag is validated, reading cannot fail.
  archive >> *_animation;

  return true;
}

static void load_skeleton(void) {
  //  const char* skeleton_file = "../media/skeleton.ozz";
  const char* skeleton_file = "../media/MixamoYBot-skeleton.ozz";
  if (!LoadSkeleton(skeleton_file, &state.ozz->skeleton)) {
    std::cerr << "Could not load skeleton " << skeleton_file << std::endl;
    return;
  }

  const int num_soa_joints = state.ozz->skeleton.num_soa_joints();
  const int num_joints = state.ozz->skeleton.num_joints();
  state.ozz->local_matrices.resize(num_soa_joints);
  state.ozz->model_matrices.resize(num_joints);
  state.ozz->cache.Resize(num_joints);
  state.loaded.skeleton = true;
  std::cout << "Successfully loaded " << skeleton_file
            << " (soa: " << num_soa_joints << ", joints: " << num_joints << ")"
            << std::endl;
}

static void load_animation(void) {
  //  const char* anim_file = "../media/animation1.ozz";
  const char* anim_file = "../media/RunningSlow-loop.ozz";
  if (!LoadAnimation(anim_file, &state.ozz->animation)) {
    std::cerr << "Could not load animation " << anim_file << std::endl;
    return;
  }

  state.loaded.animation = true;
  std::cout << "Successfully loade " << anim_file << std::endl;
}

static void draw_ui() {
  // 1. Show a simple window
  // Tip: if we don't call ImGui::Begin()/ImGui::End() the widgets appears in a window automatically called "Debug"
  ImGui::Begin("Animation");

  ImGui::Checkbox("Time override", &state.time.anim_ratio_ui_override);

  const float anim_duration = state.ozz->animation.duration();
  if (!state.time.anim_ratio_ui_override) {
    state.time.anim_ratio =
        fmodf((float)state.time.absolute / anim_duration, 1.0f);
  }
  ImGui::SliderFloat("Time", &state.time.anim_ratio, 0.f, 1.f);

  ImGui::Text(
      "Application average %.3f ms/frame (%.1f FPS)",
      1000.0f / ImGui::GetIO().Framerate,
      ImGui::GetIO().Framerate);

  ImGui::End();
}

static void frame() {
  if (state.loaded.animation && state.loaded.skeleton) {
    if (!state.time.paused) {
      state.time.absolute += state.time.frame * state.time.factor;
    }
    eval_animation();
    draw_skeleton();
  }
}

static void eval_animation() {
  // convert current time to animation ration (0.0 .. 1.0)
  const float anim_duration = state.ozz->animation.duration();
  if (!state.time.anim_ratio_ui_override) {
    state.time.anim_ratio =
        fmodf((float)state.time.absolute / anim_duration, 1.0f);
  }

  // sample animation
  ozz::animation::SamplingJob sampling_job;
  sampling_job.animation = &state.ozz->animation;
  sampling_job.cache = &state.ozz->cache;
  sampling_job.ratio = state.time.anim_ratio;
  sampling_job.output = make_span(state.ozz->local_matrices);
  sampling_job.Run();

  // convert joint matrices from local to model space
  ozz::animation::LocalToModelJob ltm_job;
  ltm_job.skeleton = &state.ozz->skeleton;
  ltm_job.input = make_span(state.ozz->local_matrices);
  ltm_job.output = make_span(state.ozz->model_matrices);
  ltm_job.Run();
}

static void draw_vec(const ozz::math::SimdFloat4& vec) {
  sgl_v3f(ozz::math::GetX(vec), ozz::math::GetY(vec), ozz::math::GetZ(vec));
}

static void draw_line(
    const ozz::math::SimdFloat4& v0,
    const ozz::math::SimdFloat4& v1) {
  draw_vec(v0);
  draw_vec(v1);
}

// this draws a wireframe 3d rhombus between the current and parent joints
static void draw_joint(int joint_index, int parent_joint_index) {
  if (parent_joint_index < 0) {
    return;
  }

  using namespace ozz::math;

  const Float4x4& m0 = state.ozz->model_matrices[joint_index];
  const Float4x4& m1 = state.ozz->model_matrices[parent_joint_index];

  const SimdFloat4 p0 = m0.cols[3];
  const SimdFloat4 p1 = m1.cols[3];
  const SimdFloat4 ny = m1.cols[1];
  const SimdFloat4 nz = m1.cols[2];

  const SimdFloat4 len = SplatX(Length3(p1 - p0)) * simd_float4::Load1(0.1f);

  const SimdFloat4 pmid = p0 + (p1 - p0) * simd_float4::Load1(0.66f);
  const SimdFloat4 p2 = pmid + ny * len;
  const SimdFloat4 p3 = pmid + nz * len;
  const SimdFloat4 p4 = pmid - ny * len;
  const SimdFloat4 p5 = pmid - nz * len;

  sgl_c3f(1.0f, 1.0f, 0.0f);
  draw_line(p0, p2);
  draw_line(p0, p3);
  draw_line(p0, p4);
  draw_line(p0, p5);
  draw_line(p1, p2);
  draw_line(p1, p3);
  draw_line(p1, p4);
  draw_line(p1, p5);
  draw_line(p2, p3);
  draw_line(p3, p4);
  draw_line(p4, p5);
  draw_line(p5, p2);
}

static void draw_skeleton(void) {
  sgl_defaults();
  sgl_matrix_mode_projection();
  sgl_load_matrix((const float*)&state.camera.proj);
  sgl_matrix_mode_modelview();
	hmm_mat4 scale_mat = HMM_Scale (HMM_Vec3(0.1f, 0.1f, 0.1f));
  sgl_load_matrix((const float*)&state.camera.view);
	sgl_mult_matrix((const float*)&scale_mat);

  const int num_joints = state.ozz->skeleton.num_joints();
  ozz::span<const int16_t> joint_parents = state.ozz->skeleton.joint_parents();
  sgl_begin_lines();
  for (int joint_index = 0; joint_index < num_joints; joint_index++) {
    draw_joint(joint_index, joint_parents[joint_index]);
  }
  sgl_end();
}

// draw ImGui draw lists via sokol-gfx
void draw_imgui(ImDrawData* draw_data) {
  assert(draw_data);
  if (draw_data->CmdListsCount == 0) {
    return;
  }

  // render the command list
  sg_apply_pipeline(pip);
  vs_params_t vs_params;
  vs_params.disp_size.x = ImGui::GetIO().DisplaySize.x;
  vs_params.disp_size.y = ImGui::GetIO().DisplaySize.y;
  sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, SG_RANGE(vs_params));
  for (int cl_index = 0; cl_index < draw_data->CmdListsCount; cl_index++) {
    const ImDrawList* cl = draw_data->CmdLists[cl_index];

    // append vertices and indices to buffers, record start offsets in resource binding struct
    const uint32_t vtx_size = cl->VtxBuffer.size() * sizeof(ImDrawVert);
    const uint32_t idx_size = cl->IdxBuffer.size() * sizeof(ImDrawIdx);
    const uint32_t vb_offset = sg_append_buffer(
        bind.vertex_buffers[0],
        {&cl->VtxBuffer.front(), vtx_size});
    const uint32_t ib_offset =
        sg_append_buffer(bind.index_buffer, {&cl->IdxBuffer.front(), idx_size});
    /* don't render anything if the buffer is in overflow state (this is also
            checked internally in sokol_gfx, draw calls that attempt from
            overflowed buffers will be silently dropped)
        */
    if (sg_query_buffer_overflow(bind.vertex_buffers[0])
        || sg_query_buffer_overflow(bind.index_buffer)) {
      continue;
    }

    bind.vertex_buffer_offsets[0] = vb_offset;
    bind.index_buffer_offset = ib_offset;
    sg_apply_bindings(&bind);

    int base_element = 0;
    for (const ImDrawCmd& pcmd : cl->CmdBuffer) {
      if (pcmd.UserCallback) {
        pcmd.UserCallback(cl, &pcmd);
      } else {
        const int scissor_x = (int)(pcmd.ClipRect.x);
        const int scissor_y = (int)(pcmd.ClipRect.y);
        const int scissor_w = (int)(pcmd.ClipRect.z - pcmd.ClipRect.x);
        const int scissor_h = (int)(pcmd.ClipRect.w - pcmd.ClipRect.y);
        sg_apply_scissor_rect(scissor_x, scissor_y, scissor_w, scissor_h, true);
        sg_draw(base_element, pcmd.ElemCount, 1);
      }
      base_element += pcmd.ElemCount;
    }
  }
}