Added build files for tracy, added ImGuizmo (not yet integrated)

.gitignore

@@ -1,7 +1,7 @@
 .*.swp
 
 .idea/**
-build**
+/build**
 cmake-build-**
 
 3rdprty/tracy/profile/build/unix/obj

3rdparty/ImGuizmo/.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+indent_style    = space
+indent_size     = 3
+end_of_line     = lf
+insert_final_newline     = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

3rdparty/ImGuizmo/.gitignore

@@ -0,0 +1,2 @@
+build/
+.*/

3rdparty/ImGuizmo/GraphEditor.h

@@ -0,0 +1,149 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#pragma once
+
+#include <vector>
+#include <stdint.h>
+#include <string>
+#include "imgui.h"
+#include "imgui_internal.h"
+
+namespace GraphEditor {
+
+typedef size_t NodeIndex;
+typedef size_t SlotIndex;
+typedef size_t LinkIndex;
+typedef size_t TemplateIndex;
+
+// Force the view to be respositionned and zoom to fit nodes with Show function.
+// Parameter value will be changed to Fit_None by the function.
+enum FitOnScreen
+{
+    Fit_None,
+    Fit_AllNodes,
+    Fit_SelectedNodes
+};
+
+// Display options and colors
+struct Options
+{
+    ImRect mMinimap{{0.75f, 0.8f, 0.99f, 0.99f}}; // rectangle coordinates of minimap
+    ImU32 mBackgroundColor{ IM_COL32(40, 40, 40, 255) }; // full background color
+    ImU32 mGridColor{ IM_COL32(0, 0, 0, 60) }; // grid lines color
+    ImU32 mGridColor2{ IM_COL32(0, 0, 0, 160) }; // grid lines color every 10th
+    ImU32 mSelectedNodeBorderColor{ IM_COL32(255, 130, 30, 255) }; // node border color when it's selected
+    ImU32 mNodeBorderColor{ IM_COL32(100, 100, 100, 0) }; // node border color when it's not selected
+    ImU32 mQuadSelection{ IM_COL32(255, 32, 32, 64) }; // quad selection inside color
+    ImU32 mQuadSelectionBorder{ IM_COL32(255, 32, 32, 255) }; // quad selection border color
+    ImU32 mDefaultSlotColor{ IM_COL32(128, 128, 128, 255) }; // when no color is provided in node template, use this value
+    ImU32 mFrameFocus{ IM_COL32(64, 128, 255, 255) }; // rectangle border when graph editor has focus
+    float mLineThickness{ 5 }; // links width in pixels when zoom value is 1
+    float mGridSize{ 64.f }; // background grid size in pixels when zoom value is 1
+    float mRounding{ 3.f }; // rounding at node corners
+    float mZoomRatio{ 0.1f }; // factor per mouse wheel delta
+    float mZoomLerpFactor{ 0.25f }; // the smaller, the smoother
+    float mBorderSelectionThickness{ 6.f }; // thickness of selection border around nodes
+    float mBorderThickness{ 6.f }; // thickness of selection border around nodes
+    float mNodeSlotRadius{ 8.f }; // circle radius for inputs and outputs
+    float mNodeSlotHoverFactor{ 1.2f }; // increase size when hovering
+    float mMinZoom{ 0.2f }, mMaxZoom { 1.1f };
+    float mSnap{ 5.f };
+    bool mDisplayLinksAsCurves{ true }; // false is straight and 45deg lines
+    bool mAllowQuadSelection{ true }; // multiple selection using drag and drop
+    bool mRenderGrid{ true }; // grid or nothing
+    bool mDrawIONameOnHover{ true }; // only draw node input/output when hovering
+};
+
+// View state: scroll position and zoom factor
+struct ViewState
+{
+    ImVec2 mPosition{0.0f, 0.0f}; // scroll position
+    float mFactor{ 1.0f }; // current zoom factor
+    float mFactorTarget{ 1.0f }; // targeted zoom factor interpolated using Options.mZoomLerpFactor
+};
+
+struct Template
+{
+    ImU32 mHeaderColor;
+    ImU32 mBackgroundColor;
+    ImU32 mBackgroundColorOver;
+    ImU8 mInputCount;
+    const char** mInputNames; // can be nullptr. No text displayed.
+    ImU32* mInputColors; // can be nullptr, default slot color will be used.
+    ImU8 mOutputCount;
+    const char** mOutputNames; // can be nullptr. No text displayed.
+    ImU32* mOutputColors; // can be nullptr, default slot color will be used.
+};
+
+struct Node
+{
+    const char* mName;
+    TemplateIndex mTemplateIndex;
+    ImRect mRect;
+    bool mSelected{ false };
+};
+
+struct Link
+{
+    NodeIndex mInputNodeIndex;
+    SlotIndex mInputSlotIndex;
+    NodeIndex mOutputNodeIndex;
+    SlotIndex mOutputSlotIndex;
+};
+
+struct Delegate
+{
+    virtual bool AllowedLink(NodeIndex from, NodeIndex to) = 0;
+
+    virtual void SelectNode(NodeIndex nodeIndex, bool selected) = 0;
+    virtual void MoveSelectedNodes(const ImVec2 delta) = 0;
+    
+    virtual void AddLink(NodeIndex inputNodeIndex, SlotIndex inputSlotIndex, NodeIndex outputNodeIndex, SlotIndex outputSlotIndex) = 0;
+    virtual void DelLink(LinkIndex linkIndex) = 0;
+    
+    // user is responsible for clipping
+    virtual void CustomDraw(ImDrawList* drawList, ImRect rectangle, NodeIndex nodeIndex) = 0;
+    
+    // use mouse position to open context menu
+    // if nodeIndex != -1, right click happens on the specified node
+    virtual void RightClick(NodeIndex nodeIndex, SlotIndex slotIndexInput, SlotIndex slotIndexOutput) = 0;
+
+    virtual const size_t GetTemplateCount() = 0;
+    virtual const Template GetTemplate(TemplateIndex index) = 0;
+
+    virtual const size_t GetNodeCount() = 0;
+    virtual const Node GetNode(NodeIndex index) = 0;
+    
+    virtual const size_t GetLinkCount() = 0;
+    virtual const Link GetLink(LinkIndex index) = 0;
+};
+
+void Show(Delegate& delegate, const Options& options, ViewState& viewState, bool enabled, FitOnScreen* fit = nullptr);
+void GraphEditorClear();
+
+bool EditOptions(Options& options);
+
+} // namespace

3rdparty/ImGuizmo/ImCurveEdit.cpp

@@ -0,0 +1,457 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#include "ImCurveEdit.h"
+#include "imgui.h"
+#include "imgui_internal.h"
+#include <stdint.h>
+#include <set>
+#include <vector>
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <malloc.h>
+#endif
+#if !defined(_MSC_VER) && !defined(__MINGW64_VERSION_MAJOR)
+#define _malloca(x) alloca(x)
+#define _freea(x)
+#endif
+
+namespace ImCurveEdit
+{
+
+#ifndef IMGUI_DEFINE_MATH_OPERATORS
+   static ImVec2 operator+(const ImVec2& a, const ImVec2& b) {
+      return ImVec2(a.x + b.x, a.y + b.y);
+   }
+
+   static ImVec2 operator-(const ImVec2& a, const ImVec2& b) {
+      return ImVec2(a.x - b.x, a.y - b.y);
+   }
+
+   static ImVec2 operator*(const ImVec2& a, const ImVec2& b) {
+      return ImVec2(a.x * b.x, a.y * b.y);
+   }
+
+   static ImVec2 operator/(const ImVec2& a, const ImVec2& b) {
+      return ImVec2(a.x / b.x, a.y / b.y);
+   }
+
+   static ImVec2 operator*(const ImVec2& a, const float b) {
+      return ImVec2(a.x * b, a.y * b);
+   }
+#endif
+
+   static float smoothstep(float edge0, float edge1, float x)
+   {
+      x = ImClamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
+      return x * x * (3 - 2 * x);
+   }
+
+   static float distance(float x, float y, float x1, float y1, float x2, float y2)
+   {
+      float A = x - x1;
+      float B = y - y1;
+      float C = x2 - x1;
+      float D = y2 - y1;
+
+      float dot = A * C + B * D;
+      float len_sq = C * C + D * D;
+      float param = -1.f;
+      if (len_sq > FLT_EPSILON)
+         param = dot / len_sq;
+
+      float xx, yy;
+
+      if (param < 0.f) {
+         xx = x1;
+         yy = y1;
+      }
+      else if (param > 1.f) {
+         xx = x2;
+         yy = y2;
+      }
+      else {
+         xx = x1 + param * C;
+         yy = y1 + param * D;
+      }
+
+      float dx = x - xx;
+      float dy = y - yy;
+      return sqrtf(dx * dx + dy * dy);
+   }
+
+   static int DrawPoint(ImDrawList* draw_list, ImVec2 pos, const ImVec2 size, const ImVec2 offset, bool edited)
+   {
+      int ret = 0;
+      ImGuiIO& io = ImGui::GetIO();
+
+      static const ImVec2 localOffsets[4] = { ImVec2(1,0), ImVec2(0,1), ImVec2(-1,0), ImVec2(0,-1) };
+      ImVec2 offsets[4];
+      for (int i = 0; i < 4; i++)
+      {
+         offsets[i] = pos * size + localOffsets[i] * 4.5f + offset;
+      }
+
+      const ImVec2 center = pos * size + offset;
+      const ImRect anchor(center - ImVec2(5, 5), center + ImVec2(5, 5));
+      draw_list->AddConvexPolyFilled(offsets, 4, 0xFF000000);
+      if (anchor.Contains(io.MousePos))
+      {
+         ret = 1;
+         if (io.MouseDown[0])
+            ret = 2;
+      }
+      if (edited)
+         draw_list->AddPolyline(offsets, 4, 0xFFFFFFFF, true, 3.0f);
+      else if (ret)
+         draw_list->AddPolyline(offsets, 4, 0xFF80B0FF, true, 2.0f);
+      else
+         draw_list->AddPolyline(offsets, 4, 0xFF0080FF, true, 2.0f);
+
+      return ret;
+   }
+
+   int Edit(Delegate& delegate, const ImVec2& size, unsigned int id, const ImRect* clippingRect, ImVector<EditPoint>* selectedPoints)
+   {
+      static bool selectingQuad = false;
+      static ImVec2 quadSelection;
+      static int overCurve = -1;
+      static int movingCurve = -1;
+      static bool scrollingV = false;
+      static std::set<EditPoint> selection;
+      static bool overSelectedPoint = false;
+
+      int ret = 0;
+
+      ImGuiIO& io = ImGui::GetIO();
+      ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
+      ImGui::PushStyleColor(ImGuiCol_Border, 0);
+      ImGui::BeginChildFrame(id, size);
+      delegate.focused = ImGui::IsWindowFocused();
+      ImDrawList* draw_list = ImGui::GetWindowDrawList();
+      if (clippingRect)
+         draw_list->PushClipRect(clippingRect->Min, clippingRect->Max, true);
+
+      const ImVec2 offset = ImGui::GetCursorScreenPos() + ImVec2(0.f, size.y);
+      const ImVec2 ssize(size.x, -size.y);
+      const ImRect container(offset + ImVec2(0.f, ssize.y), offset + ImVec2(ssize.x, 0.f));
+      ImVec2& min = delegate.GetMin();
+      ImVec2& max = delegate.GetMax();
+
+      // handle zoom and VScroll
+      if (container.Contains(io.MousePos))
+      {
+         if (fabsf(io.MouseWheel) > FLT_EPSILON)
+         {
+            const float r = (io.MousePos.y - offset.y) / ssize.y;
+            float ratioY = ImLerp(min.y, max.y, r);
+            auto scaleValue = [&](float v) {
+               v -= ratioY;
+               v *= (1.f - io.MouseWheel * 0.05f);
+               v += ratioY;
+               return v;
+            };
+            min.y = scaleValue(min.y);
+            max.y = scaleValue(max.y);
+         }
+         if (!scrollingV && ImGui::IsMouseDown(2))
+         {
+            scrollingV = true;
+         }
+      }
+      ImVec2 range = max - min + ImVec2(1.f, 0.f);  // +1 because of inclusive last frame
+
+      const ImVec2 viewSize(size.x, -size.y);
+      const ImVec2 sizeOfPixel = ImVec2(1.f, 1.f) / viewSize;
+      const size_t curveCount = delegate.GetCurveCount();
+
+      if (scrollingV)
+      {
+         float deltaH = io.MouseDelta.y * range.y * sizeOfPixel.y;
+         min.y -= deltaH;
+         max.y -= deltaH;
+         if (!ImGui::IsMouseDown(2))
+            scrollingV = false;
+      }
+
+      draw_list->AddRectFilled(offset, offset + ssize, delegate.GetBackgroundColor());
+
+      auto pointToRange = [&](ImVec2 pt) { return (pt - min) / range; };
+      auto rangeToPoint = [&](ImVec2 pt) { return (pt * range) + min; };
+
+      draw_list->AddLine(ImVec2(-1.f, -min.y / range.y) * viewSize + offset, ImVec2(1.f, -min.y / range.y) * viewSize + offset, 0xFF000000, 1.5f);
+      bool overCurveOrPoint = false;
+
+      int localOverCurve = -1;
+      // make sure highlighted curve is rendered last
+      int* curvesIndex = (int*)_malloca(sizeof(int) * curveCount);
+      for (size_t c = 0; c < curveCount; c++)
+         curvesIndex[c] = int(c);
+      int highLightedCurveIndex = -1;
+      if (overCurve != -1 && curveCount)
+      {
+         ImSwap(curvesIndex[overCurve], curvesIndex[curveCount - 1]);
+         highLightedCurveIndex = overCurve;
+      }
+
+      for (size_t cur = 0; cur < curveCount; cur++)
+      {
+         int c = curvesIndex[cur];
+         if (!delegate.IsVisible(c))
+            continue;
+         const size_t ptCount = delegate.GetPointCount(c);
+         if (ptCount < 1)
+            continue;
+         CurveType curveType = delegate.GetCurveType(c);
+         if (curveType == CurveNone)
+            continue;
+         const ImVec2* pts = delegate.GetPoints(c);
+         uint32_t curveColor = delegate.GetCurveColor(c);
+         if ((c == highLightedCurveIndex && selection.empty() && !selectingQuad) || movingCurve == c)
+            curveColor = 0xFFFFFFFF;
+
+         for (size_t p = 0; p < ptCount - 1; p++)
+         {
+            const ImVec2 p1 = pointToRange(pts[p]);
+            const ImVec2 p2 = pointToRange(pts[p + 1]);
+
+            if (curveType == CurveSmooth || curveType == CurveLinear)
+            {
+               size_t subStepCount = (curveType == CurveSmooth) ? 20 : 2;
+               float step = 1.f / float(subStepCount - 1);
+               for (size_t substep = 0; substep < subStepCount - 1; substep++)
+               {
+                  float t = float(substep) * step;
+
+                  const ImVec2 sp1 = ImLerp(p1, p2, t);
+                  const ImVec2 sp2 = ImLerp(p1, p2, t + step);
+
+                  const float rt1 = smoothstep(p1.x, p2.x, sp1.x);
+                  const float rt2 = smoothstep(p1.x, p2.x, sp2.x);
+
+                  const ImVec2 pos1 = ImVec2(sp1.x, ImLerp(p1.y, p2.y, rt1)) * viewSize + offset;
+                  const ImVec2 pos2 = ImVec2(sp2.x, ImLerp(p1.y, p2.y, rt2)) * viewSize + offset;
+
+                  if (distance(io.MousePos.x, io.MousePos.y, pos1.x, pos1.y, pos2.x, pos2.y) < 8.f && !scrollingV)
+                  {
+                     localOverCurve = int(c);
+                     overCurve = int(c);
+                     overCurveOrPoint = true;
+                  }
+
+                  draw_list->AddLine(pos1, pos2, curveColor, 1.3f);
+               } // substep
+            }
+            else if (curveType == CurveDiscrete)
+            {
+               ImVec2 dp1 = p1 * viewSize + offset;
+               ImVec2 dp2 = ImVec2(p2.x, p1.y) * viewSize + offset;
+               ImVec2 dp3 = p2 * viewSize + offset;
+               draw_list->AddLine(dp1, dp2, curveColor, 1.3f);
+               draw_list->AddLine(dp2, dp3, curveColor, 1.3f);
+
+               if ((distance(io.MousePos.x, io.MousePos.y, dp1.x, dp1.y, dp3.x, dp1.y) < 8.f ||
+                  distance(io.MousePos.x, io.MousePos.y, dp3.x, dp1.y, dp3.x, dp3.y) < 8.f)
+                  /*&& localOverCurve == -1*/)
+               {
+                  localOverCurve = int(c);
+                  overCurve = int(c);
+                  overCurveOrPoint = true;
+               }
+            }
+         } // point loop
+
+         for (size_t p = 0; p < ptCount; p++)
+         {
+            const int drawState = DrawPoint(draw_list, pointToRange(pts[p]), viewSize, offset, (selection.find({ int(c), int(p) }) != selection.end() && movingCurve == -1 && !scrollingV));
+            if (drawState && movingCurve == -1 && !selectingQuad)
+            {
+               overCurveOrPoint = true;
+               overSelectedPoint = true;
+               overCurve = -1;
+               if (drawState == 2)
+               {
+                  if (!io.KeyShift && selection.find({ int(c), int(p) }) == selection.end())
+                     selection.clear();
+                  selection.insert({ int(c), int(p) });
+               }
+            }
+         }
+      } // curves loop
+
+      if (localOverCurve == -1)
+         overCurve = -1;
+
+      // move selection
+      static bool pointsMoved = false;
+      static ImVec2 mousePosOrigin;
+      static std::vector<ImVec2> originalPoints;
+      if (overSelectedPoint && io.MouseDown[0])
+      {
+         if ((fabsf(io.MouseDelta.x) > 0.f || fabsf(io.MouseDelta.y) > 0.f) && !selection.empty())
+         {
+            if (!pointsMoved)
+            {
+               delegate.BeginEdit(0);
+               mousePosOrigin = io.MousePos;
+               originalPoints.resize(selection.size());
+               int index = 0;
+               for (auto& sel : selection)
+               {
+                  const ImVec2* pts = delegate.GetPoints(sel.curveIndex);
+                  originalPoints[index++] = pts[sel.pointIndex];
+               }
+            }
+            pointsMoved = true;
+            ret = 1;
+            auto prevSelection = selection;
+            int originalIndex = 0;
+            for (auto& sel : prevSelection)
+            {
+               const ImVec2 p = rangeToPoint(pointToRange(originalPoints[originalIndex]) + (io.MousePos - mousePosOrigin) * sizeOfPixel);
+               const int newIndex = delegate.EditPoint(sel.curveIndex, sel.pointIndex, p);
+               if (newIndex != sel.pointIndex)
+               {
+                  selection.erase(sel);
+                  selection.insert({ sel.curveIndex, newIndex });
+               }
+               originalIndex++;
+            }
+         }
+      }
+
+      if (overSelectedPoint && !io.MouseDown[0])
+      {
+         overSelectedPoint = false;
+         if (pointsMoved)
+         {
+            pointsMoved = false;
+            delegate.EndEdit();
+         }
+      }
+
+      // add point
+      if (overCurve != -1 && io.MouseDoubleClicked[0])
+      {
+         const ImVec2 np = rangeToPoint((io.MousePos - offset) / viewSize);
+         delegate.BeginEdit(overCurve);
+         delegate.AddPoint(overCurve, np);
+         delegate.EndEdit();
+         ret = 1;
+      }
+
+      // move curve
+
+      if (movingCurve != -1)
+      {
+         const size_t ptCount = delegate.GetPointCount(movingCurve);
+         const ImVec2* pts = delegate.GetPoints(movingCurve);
+         if (!pointsMoved)
+         {
+            mousePosOrigin = io.MousePos;
+            pointsMoved = true;
+            originalPoints.resize(ptCount);
+            for (size_t index = 0; index < ptCount; index++)
+            {
+               originalPoints[index] = pts[index];
+            }
+         }
+         if (ptCount >= 1)
+         {
+            for (size_t p = 0; p < ptCount; p++)
+            {
+               delegate.EditPoint(movingCurve, int(p), rangeToPoint(pointToRange(originalPoints[p]) + (io.MousePos - mousePosOrigin) * sizeOfPixel));
+            }
+            ret = 1;
+         }
+         if (!io.MouseDown[0])
+         {
+            movingCurve = -1;
+            pointsMoved = false;
+            delegate.EndEdit();
+         }
+      }
+      if (movingCurve == -1 && overCurve != -1 && ImGui::IsMouseClicked(0) && selection.empty() && !selectingQuad)
+      {
+         movingCurve = overCurve;
+         delegate.BeginEdit(overCurve);
+      }
+
+      // quad selection
+      if (selectingQuad)
+      {
+         const ImVec2 bmin = ImMin(quadSelection, io.MousePos);
+         const ImVec2 bmax = ImMax(quadSelection, io.MousePos);
+         draw_list->AddRectFilled(bmin, bmax, 0x40FF0000, 1.f);
+         draw_list->AddRect(bmin, bmax, 0xFFFF0000, 1.f);
+         const ImRect selectionQuad(bmin, bmax);
+         if (!io.MouseDown[0])
+         {
+            if (!io.KeyShift)
+               selection.clear();
+            // select everythnig is quad
+            for (size_t c = 0; c < curveCount; c++)
+            {
+               if (!delegate.IsVisible(c))
+                  continue;
+
+               const size_t ptCount = delegate.GetPointCount(c);
+               if (ptCount < 1)
+                  continue;
+
+               const ImVec2* pts = delegate.GetPoints(c);
+               for (size_t p = 0; p < ptCount; p++)
+               {
+                  const ImVec2 center = pointToRange(pts[p]) * viewSize + offset;
+                  if (selectionQuad.Contains(center))
+                     selection.insert({ int(c), int(p) });
+               }
+            }
+            // done
+            selectingQuad = false;
+         }
+      }
+      if (!overCurveOrPoint && ImGui::IsMouseClicked(0) && !selectingQuad && movingCurve == -1 && !overSelectedPoint && container.Contains(io.MousePos))
+      {
+         selectingQuad = true;
+         quadSelection = io.MousePos;
+      }
+      if (clippingRect)
+         draw_list->PopClipRect();
+
+      ImGui::EndChildFrame();
+      ImGui::PopStyleVar();
+      ImGui::PopStyleColor(1);
+
+      if (selectedPoints)
+      {
+         selectedPoints->resize(int(selection.size()));
+         int index = 0;
+         for (auto& point : selection)
+            (*selectedPoints)[index++] = point;
+      }
+      return ret;
+   }
+}

3rdparty/ImGuizmo/ImCurveEdit.h

@@ -0,0 +1,80 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#pragma once
+#include <stdint.h>
+#include "imgui.h"
+
+struct ImRect;
+
+namespace ImCurveEdit
+{
+   enum CurveType
+   {
+      CurveNone,
+      CurveDiscrete,
+      CurveLinear,
+      CurveSmooth,
+      CurveBezier,
+   };
+
+   struct EditPoint
+   {
+      int curveIndex;
+      int pointIndex;
+      bool operator <(const EditPoint& other) const
+      {
+         if (curveIndex < other.curveIndex)
+            return true;
+         if (curveIndex > other.curveIndex)
+            return false;
+
+         if (pointIndex < other.pointIndex)
+            return true;
+         return false;
+      }
+   };
+
+   struct Delegate
+   {
+      bool focused = false;
+      virtual size_t GetCurveCount() = 0;
+      virtual bool IsVisible(size_t /*curveIndex*/) { return true; }
+      virtual CurveType GetCurveType(size_t /*curveIndex*/) const { return CurveLinear; }
+      virtual ImVec2& GetMin() = 0;
+      virtual ImVec2& GetMax() = 0;
+      virtual size_t GetPointCount(size_t curveIndex) = 0;
+      virtual uint32_t GetCurveColor(size_t curveIndex) = 0;
+      virtual ImVec2* GetPoints(size_t curveIndex) = 0;
+      virtual int EditPoint(size_t curveIndex, int pointIndex, ImVec2 value) = 0;
+      virtual void AddPoint(size_t curveIndex, ImVec2 value) = 0;
+      virtual unsigned int GetBackgroundColor() { return 0xFF202020; }
+      // handle undo/redo thru this functions
+      virtual void BeginEdit(int /*index*/) {}
+      virtual void EndEdit() {}
+   };
+
+   int Edit(Delegate& delegate, const ImVec2& size, unsigned int id, const ImRect* clippingRect = NULL, ImVector<EditPoint>* selectedPoints = NULL);
+}

3rdparty/ImGuizmo/ImGradient.cpp

@@ -0,0 +1,116 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#include "ImGradient.h"
+#include "imgui.h"
+#include "imgui_internal.h"
+
+namespace ImGradient
+{
+#ifndef IMGUI_DEFINE_MATH_OPERATORS
+   static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x * rhs, lhs.y * rhs); }
+   static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x / rhs, lhs.y / rhs); }
+   static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x + rhs.x, lhs.y + rhs.y); }
+   static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x - rhs.x, lhs.y - rhs.y); }
+   static inline ImVec2 operator*(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
+   static inline ImVec2 operator/(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x / rhs.x, lhs.y / rhs.y); }
+#endif
+
+   static int DrawPoint(ImDrawList* draw_list, ImVec4 color, const ImVec2 size, bool editing, ImVec2 pos)
+   {
+      ImGuiIO& io = ImGui::GetIO();
+
+      ImVec2 p1 = ImLerp(pos, ImVec2(pos + ImVec2(size.x - size.y, 0.f)), color.w) + ImVec2(3, 3);
+      ImVec2 p2 = ImLerp(pos + ImVec2(size.y, size.y), ImVec2(pos + size), color.w) - ImVec2(3, 3);
+      ImRect rc(p1, p2);
+
+      color.w = 1.f;
+      draw_list->AddRectFilled(p1, p2, ImColor(color));
+      if (editing)
+         draw_list->AddRect(p1, p2, 0xFFFFFFFF, 2.f, 15, 2.5f);
+      else
+         draw_list->AddRect(p1, p2, 0x80FFFFFF, 2.f, 15, 1.25f);
+
+      if (rc.Contains(io.MousePos))
+      {
+         if (io.MouseClicked[0])
+            return 2;
+         return 1;
+      }
+      return 0;
+   }
+
+   bool Edit(Delegate& delegate, const ImVec2& size, int& selection)
+   {
+      bool ret = false;
+      ImGuiIO& io = ImGui::GetIO();
+      ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
+      ImGui::BeginChildFrame(137, size);
+
+      ImDrawList* draw_list = ImGui::GetWindowDrawList();
+      const ImVec2 offset = ImGui::GetCursorScreenPos();
+
+      const ImVec4* pts = delegate.GetPoints();
+      static int currentSelection = -1;
+      static int movingPt = -1;
+      if (currentSelection >= int(delegate.GetPointCount()))
+         currentSelection = -1;
+      if (movingPt != -1)
+      {
+         ImVec4 current = pts[movingPt];
+         current.w += io.MouseDelta.x / size.x;
+         current.w = ImClamp(current.w, 0.f, 1.f);
+         delegate.EditPoint(movingPt, current);
+         ret = true;
+         if (!io.MouseDown[0])
+            movingPt = -1;
+      }
+      for (size_t i = 0; i < delegate.GetPointCount(); i++)
+      {
+         int ptSel = DrawPoint(draw_list, pts[i], size, i == currentSelection, offset);
+         if (ptSel == 2)
+         {
+            currentSelection = int(i);
+            ret = true;
+         }
+         if (ptSel == 1 && io.MouseDown[0] && movingPt == -1)
+         {
+            movingPt = int(i);
+         }
+      }
+      ImRect rc(offset, offset + size);
+      if (rc.Contains(io.MousePos) && io.MouseDoubleClicked[0])
+      {
+         float t = (io.MousePos.x - offset.x) / size.x;
+         delegate.AddPoint(delegate.GetPoint(t));
+         ret = true;
+      }
+      ImGui::EndChildFrame();
+      ImGui::PopStyleVar();
+
+      selection = currentSelection;
+      return ret;
+   }
+}

3rdparty/ImGuizmo/ImGradient.h

@@ -0,0 +1,44 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#pragma once
+#include <cstddef>
+
+struct ImVec4;
+struct ImVec2;
+
+namespace ImGradient
+{
+   struct Delegate
+   {
+      virtual size_t GetPointCount() = 0;
+      virtual ImVec4* GetPoints() = 0;
+      virtual int EditPoint(int pointIndex, ImVec4 value) = 0;
+      virtual ImVec4 GetPoint(float t) = 0;
+      virtual void AddPoint(ImVec4 value) = 0;
+   };
+
+   bool Edit(Delegate& delegate, const ImVec2& size, int& selection);
+}

3rdparty/ImGuizmo/ImGuizmo.h

@@ -0,0 +1,219 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+// -------------------------------------------------------------------------------------------
+// History :
+// 2019/11/03 View gizmo
+// 2016/09/11 Behind camera culling. Scaling Delta matrix not multiplied by source matrix scales. local/world rotation and translation fixed. Display message is incorrect (X: ... Y:...) in local mode.
+// 2016/09/09 Hatched negative axis. Snapping. Documentation update.
+// 2016/09/04 Axis switch and translation plan autohiding. Scale transform stability improved
+// 2016/09/01 Mogwai changed to Manipulate. Draw debug cube. Fixed inverted scale. Mixing scale and translation/rotation gives bad results.
+// 2016/08/31 First version
+//
+// -------------------------------------------------------------------------------------------
+// Future (no order):
+//
+// - Multi view
+// - display rotation/translation/scale infos in local/world space and not only local
+// - finish local/world matrix application
+// - OPERATION as bitmask
+// 
+// -------------------------------------------------------------------------------------------
+// Example 
+#if 0
+void EditTransform(const Camera& camera, matrix_t& matrix)
+{
+   static ImGuizmo::OPERATION mCurrentGizmoOperation(ImGuizmo::ROTATE);
+   static ImGuizmo::MODE mCurrentGizmoMode(ImGuizmo::WORLD);
+   if (ImGui::IsKeyPressed(90))
+      mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+   if (ImGui::IsKeyPressed(69))
+      mCurrentGizmoOperation = ImGuizmo::ROTATE;
+   if (ImGui::IsKeyPressed(82)) // r Key
+      mCurrentGizmoOperation = ImGuizmo::SCALE;
+   if (ImGui::RadioButton("Translate", mCurrentGizmoOperation == ImGuizmo::TRANSLATE))
+      mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+   ImGui::SameLine();
+   if (ImGui::RadioButton("Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE))
+      mCurrentGizmoOperation = ImGuizmo::ROTATE;
+   ImGui::SameLine();
+   if (ImGui::RadioButton("Scale", mCurrentGizmoOperation == ImGuizmo::SCALE))
+      mCurrentGizmoOperation = ImGuizmo::SCALE;
+   float matrixTranslation[3], matrixRotation[3], matrixScale[3];
+   ImGuizmo::DecomposeMatrixToComponents(matrix.m16, matrixTranslation, matrixRotation, matrixScale);
+   ImGui::InputFloat3("Tr", matrixTranslation, 3);
+   ImGui::InputFloat3("Rt", matrixRotation, 3);
+   ImGui::InputFloat3("Sc", matrixScale, 3);
+   ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, matrix.m16);
+
+   if (mCurrentGizmoOperation != ImGuizmo::SCALE)
+   {
+      if (ImGui::RadioButton("Local", mCurrentGizmoMode == ImGuizmo::LOCAL))
+         mCurrentGizmoMode = ImGuizmo::LOCAL;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("World", mCurrentGizmoMode == ImGuizmo::WORLD))
+         mCurrentGizmoMode = ImGuizmo::WORLD;
+   }
+   static bool useSnap(false);
+   if (ImGui::IsKeyPressed(83))
+      useSnap = !useSnap;
+   ImGui::Checkbox("", &useSnap);
+   ImGui::SameLine();
+   vec_t snap;
+   switch (mCurrentGizmoOperation)
+   {
+   case ImGuizmo::TRANSLATE:
+      snap = config.mSnapTranslation;
+      ImGui::InputFloat3("Snap", &snap.x);
+      break;
+   case ImGuizmo::ROTATE:
+      snap = config.mSnapRotation;
+      ImGui::InputFloat("Angle Snap", &snap.x);
+      break;
+   case ImGuizmo::SCALE:
+      snap = config.mSnapScale;
+      ImGui::InputFloat("Scale Snap", &snap.x);
+      break;
+   }
+   ImGuiIO& io = ImGui::GetIO();
+   ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);
+   ImGuizmo::Manipulate(camera.mView.m16, camera.mProjection.m16, mCurrentGizmoOperation, mCurrentGizmoMode, matrix.m16, NULL, useSnap ? &snap.x : NULL);
+}
+#endif
+#pragma once
+
+#ifdef USE_IMGUI_API
+#include "imconfig.h"
+#endif
+#ifndef IMGUI_API
+#define IMGUI_API
+#endif
+
+namespace ImGuizmo
+{
+   // call inside your own window and before Manipulate() in order to draw gizmo to that window.
+   // Or pass a specific ImDrawList to draw to (e.g. ImGui::GetForegroundDrawList()).
+   IMGUI_API void SetDrawlist(ImDrawList* drawlist = nullptr);
+
+   // call BeginFrame right after ImGui_XXXX_NewFrame();
+   IMGUI_API void BeginFrame();
+
+   // this is necessary because when imguizmo is compiled into a dll, and imgui into another
+   // globals are not shared between them.
+   // More details at https://stackoverflow.com/questions/19373061/what-happens-to-global-and-static-variables-in-a-shared-library-when-it-is-dynam
+   // expose method to set imgui context
+   IMGUI_API void SetImGuiContext(ImGuiContext* ctx);
+
+   // return true if mouse cursor is over any gizmo control (axis, plan or screen component)
+   IMGUI_API bool IsOver();
+
+   // return true if mouse IsOver or if the gizmo is in moving state
+   IMGUI_API bool IsUsing();
+
+   // enable/disable the gizmo. Stay in the state until next call to Enable.
+   // gizmo is rendered with gray half transparent color when disabled
+   IMGUI_API void Enable(bool enable);
+
+   // helper functions for manualy editing translation/rotation/scale with an input float
+   // translation, rotation and scale float points to 3 floats each
+   // Angles are in degrees (more suitable for human editing)
+   // example:
+   // float matrixTranslation[3], matrixRotation[3], matrixScale[3];
+   // ImGuizmo::DecomposeMatrixToComponents(gizmoMatrix.m16, matrixTranslation, matrixRotation, matrixScale);
+   // ImGui::InputFloat3("Tr", matrixTranslation, 3);
+   // ImGui::InputFloat3("Rt", matrixRotation, 3);
+   // ImGui::InputFloat3("Sc", matrixScale, 3);
+   // ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, gizmoMatrix.m16);
+   //
+   // These functions have some numerical stability issues for now. Use with caution.
+   IMGUI_API void DecomposeMatrixToComponents(const float* matrix, float* translation, float* rotation, float* scale);
+   IMGUI_API void RecomposeMatrixFromComponents(const float* translation, const float* rotation, const float* scale, float* matrix);
+
+   IMGUI_API void SetRect(float x, float y, float width, float height);
+   // default is false
+   IMGUI_API void SetOrthographic(bool isOrthographic);
+
+   // Render a cube with face color corresponding to face normal. Usefull for debug/tests
+   IMGUI_API void DrawCubes(const float* view, const float* projection, const float* matrices, int matrixCount);
+   IMGUI_API void DrawGrid(const float* view, const float* projection, const float* matrix, const float gridSize);
+
+   // call it when you want a gizmo
+   // Needs view and projection matrices. 
+   // matrix parameter is the source matrix (where will be gizmo be drawn) and might be transformed by the function. Return deltaMatrix is optional
+   // translation is applied in world space
+   enum OPERATION
+   {
+      TRANSLATE_X      = (1u << 0),
+      TRANSLATE_Y      = (1u << 1),
+      TRANSLATE_Z      = (1u << 2),
+      ROTATE_X         = (1u << 3),
+      ROTATE_Y         = (1u << 4),
+      ROTATE_Z         = (1u << 5),
+      ROTATE_SCREEN    = (1u << 6),
+      SCALE_X          = (1u << 7),
+      SCALE_Y          = (1u << 8),
+      SCALE_Z          = (1u << 9),
+      BOUNDS           = (1u << 10),
+      SCALE_XU         = (1u << 11),
+      SCALE_YU         = (1u << 12),
+      SCALE_ZU         = (1u << 13),
+
+      TRANSLATE = TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z,
+      ROTATE = ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN,
+      SCALE = SCALE_X | SCALE_Y | SCALE_Z,
+      SCALEU = SCALE_XU | SCALE_YU | SCALE_ZU, // universal
+      UNIVERSAL = TRANSLATE | ROTATE | SCALEU
+   };
+
+   inline OPERATION operator|(OPERATION lhs, OPERATION rhs)
+   {
+     return static_cast<OPERATION>(static_cast<int>(lhs) | static_cast<int>(rhs));
+   }
+
+   enum MODE
+   {
+      LOCAL,
+      WORLD
+   };
+
+   IMGUI_API bool Manipulate(const float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float* deltaMatrix = NULL, const float* snap = NULL, const float* localBounds = NULL, const float* boundsSnap = NULL);
+   //
+   // Please note that this cubeview is patented by Autodesk : https://patents.google.com/patent/US7782319B2/en
+   // It seems to be a defensive patent in the US. I don't think it will bring troubles using it as
+   // other software are using the same mechanics. But just in case, you are now warned!
+   //
+   IMGUI_API void ViewManipulate(float* view, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor);
+
+   IMGUI_API void SetID(int id);
+
+   // return true if the cursor is over the operation's gizmo
+   IMGUI_API bool IsOver(OPERATION op);
+   IMGUI_API void SetGizmoSizeClipSpace(float value);
+
+   // Allow axis to flip
+   // When true (default), the guizmo axis flip for better visibility
+   // When false, they always stay along the positive world/local axis
+   IMGUI_API void AllowAxisFlip(bool value);
+}

3rdparty/ImGuizmo/ImSequencer.cpp

@@ -0,0 +1,692 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#include "ImSequencer.h"
+#include "imgui.h"
+#include "imgui_internal.h"
+#include <cstdlib>
+
+namespace ImSequencer
+{
+#ifndef IMGUI_DEFINE_MATH_OPERATORS
+   static ImVec2 operator+(const ImVec2& a, const ImVec2& b) {
+      return ImVec2(a.x + b.x, a.y + b.y);
+   }
+#endif
+   static bool SequencerAddDelButton(ImDrawList* draw_list, ImVec2 pos, bool add = true)
+   {
+      ImGuiIO& io = ImGui::GetIO();
+      ImRect delRect(pos, ImVec2(pos.x + 16, pos.y + 16));
+      bool overDel = delRect.Contains(io.MousePos);
+      int delColor = overDel ? 0xFFAAAAAA : 0x77A3B2AA;
+      float midy = pos.y + 16 / 2 - 0.5f;
+      float midx = pos.x + 16 / 2 - 0.5f;
+      draw_list->AddRect(delRect.Min, delRect.Max, delColor, 4);
+      draw_list->AddLine(ImVec2(delRect.Min.x + 3, midy), ImVec2(delRect.Max.x - 3, midy), delColor, 2);
+      if (add)
+         draw_list->AddLine(ImVec2(midx, delRect.Min.y + 3), ImVec2(midx, delRect.Max.y - 3), delColor, 2);
+      return overDel;
+   }
+
+   bool Sequencer(SequenceInterface* sequence, int* currentFrame, bool* expanded, int* selectedEntry, int* firstFrame, int sequenceOptions)
+   {
+      bool ret = false;
+      ImGuiIO& io = ImGui::GetIO();
+      int cx = (int)(io.MousePos.x);
+      int cy = (int)(io.MousePos.y);
+      static float framePixelWidth = 10.f;
+      static float framePixelWidthTarget = 10.f;
+      int legendWidth = 200;
+
+      static int movingEntry = -1;
+      static int movingPos = -1;
+      static int movingPart = -1;
+      int delEntry = -1;
+      int dupEntry = -1;
+      int ItemHeight = 20;
+
+      bool popupOpened = false;
+      int sequenceCount = sequence->GetItemCount();
+      if (!sequenceCount)
+         return false;
+      ImGui::BeginGroup();
+
+      ImDrawList* draw_list = ImGui::GetWindowDrawList();
+      ImVec2 canvas_pos = ImGui::GetCursorScreenPos();            // ImDrawList API uses screen coordinates!
+      ImVec2 canvas_size = ImGui::GetContentRegionAvail();        // Resize canvas to what's available
+      int firstFrameUsed = firstFrame ? *firstFrame : 0;
+
+
+      int controlHeight = sequenceCount * ItemHeight;
+      for (int i = 0; i < sequenceCount; i++)
+         controlHeight += int(sequence->GetCustomHeight(i));
+      int frameCount = ImMax(sequence->GetFrameMax() - sequence->GetFrameMin(), 1);
+
+      static bool MovingScrollBar = false;
+      static bool MovingCurrentFrame = false;
+      struct CustomDraw
+      {
+         int index;
+         ImRect customRect;
+         ImRect legendRect;
+         ImRect clippingRect;
+         ImRect legendClippingRect;
+      };
+      ImVector<CustomDraw> customDraws;
+      ImVector<CustomDraw> compactCustomDraws;
+      // zoom in/out
+      const int visibleFrameCount = (int)floorf((canvas_size.x - legendWidth) / framePixelWidth);
+      const float barWidthRatio = ImMin(visibleFrameCount / (float)frameCount, 1.f);
+      const float barWidthInPixels = barWidthRatio * (canvas_size.x - legendWidth);
+
+      ImRect regionRect(canvas_pos, canvas_pos + canvas_size);
+
+      static bool panningView = false;
+      static ImVec2 panningViewSource;
+      static int panningViewFrame;
+      if (ImGui::IsWindowFocused() && io.KeyAlt && io.MouseDown[2])
+      {
+         if (!panningView)
+         {
+            panningViewSource = io.MousePos;
+            panningView = true;
+            panningViewFrame = *firstFrame;
+         }
+         *firstFrame = panningViewFrame - int((io.MousePos.x - panningViewSource.x) / framePixelWidth);
+         *firstFrame = ImClamp(*firstFrame, sequence->GetFrameMin(), sequence->GetFrameMax() - visibleFrameCount);
+      }
+      if (panningView && !io.MouseDown[2])
+      {
+         panningView = false;
+      }
+      framePixelWidthTarget = ImClamp(framePixelWidthTarget, 0.1f, 50.f);
+
+      framePixelWidth = ImLerp(framePixelWidth, framePixelWidthTarget, 0.33f);
+
+      frameCount = sequence->GetFrameMax() - sequence->GetFrameMin();
+      if (visibleFrameCount >= frameCount && firstFrame)
+         *firstFrame = sequence->GetFrameMin();
+
+
+      // --
+      if (expanded && !*expanded)
+      {
+         ImGui::InvisibleButton("canvas", ImVec2(canvas_size.x - canvas_pos.x, (float)ItemHeight));
+         draw_list->AddRectFilled(canvas_pos, ImVec2(canvas_size.x + canvas_pos.x, canvas_pos.y + ItemHeight), 0xFF3D3837, 0);
+         char tmps[512];
+         ImFormatString(tmps, IM_ARRAYSIZE(tmps), "%d Frames / %d entries", frameCount, sequenceCount);
+         draw_list->AddText(ImVec2(canvas_pos.x + 26, canvas_pos.y + 2), 0xFFFFFFFF, tmps);
+      }
+      else
+      {
+         bool hasScrollBar(true);
+         /*
+         int framesPixelWidth = int(frameCount * framePixelWidth);
+         if ((framesPixelWidth + legendWidth) >= canvas_size.x)
+         {
+             hasScrollBar = true;
+         }
+         */
+         // test scroll area
+         ImVec2 headerSize(canvas_size.x, (float)ItemHeight);
+         ImVec2 scrollBarSize(canvas_size.x, 14.f);
+         ImGui::InvisibleButton("topBar", headerSize);
+         draw_list->AddRectFilled(canvas_pos, canvas_pos + headerSize, 0xFFFF0000, 0);
+         ImVec2 childFramePos = ImGui::GetCursorScreenPos();
+         ImVec2 childFrameSize(canvas_size.x, canvas_size.y - 8.f - headerSize.y - (hasScrollBar ? scrollBarSize.y : 0));
+         ImGui::PushStyleColor(ImGuiCol_FrameBg, 0);
+         ImGui::BeginChildFrame(889, childFrameSize);
+         sequence->focused = ImGui::IsWindowFocused();
+         ImGui::InvisibleButton("contentBar", ImVec2(canvas_size.x, float(controlHeight)));
+         const ImVec2 contentMin = ImGui::GetItemRectMin();
+         const ImVec2 contentMax = ImGui::GetItemRectMax();
+         const ImRect contentRect(contentMin, contentMax);
+         const float contentHeight = contentMax.y - contentMin.y;
+
+         // full background
+         draw_list->AddRectFilled(canvas_pos, canvas_pos + canvas_size, 0xFF242424, 0);
+
+         // current frame top
+         ImRect topRect(ImVec2(canvas_pos.x + legendWidth, canvas_pos.y), ImVec2(canvas_pos.x + canvas_size.x, canvas_pos.y + ItemHeight));
+
+         if (!MovingCurrentFrame && !MovingScrollBar && movingEntry == -1 && sequenceOptions & SEQUENCER_CHANGE_FRAME && currentFrame && *currentFrame >= 0 && topRect.Contains(io.MousePos) && io.MouseDown[0])
+         {
+            MovingCurrentFrame = true;
+         }
+         if (MovingCurrentFrame)
+         {
+            if (frameCount)
+            {
+               *currentFrame = (int)((io.MousePos.x - topRect.Min.x) / framePixelWidth) + firstFrameUsed;
+               if (*currentFrame < sequence->GetFrameMin())
+                  *currentFrame = sequence->GetFrameMin();
+               if (*currentFrame >= sequence->GetFrameMax())
+                  *currentFrame = sequence->GetFrameMax();
+            }
+            if (!io.MouseDown[0])
+               MovingCurrentFrame = false;
+         }
+
+         //header
+         draw_list->AddRectFilled(canvas_pos, ImVec2(canvas_size.x + canvas_pos.x, canvas_pos.y + ItemHeight), 0xFF3D3837, 0);
+         if (sequenceOptions & SEQUENCER_ADD)
+         {
+            if (SequencerAddDelButton(draw_list, ImVec2(canvas_pos.x + legendWidth - ItemHeight, canvas_pos.y + 2), true) && io.MouseReleased[0])
+               ImGui::OpenPopup("addEntry");
+
+            if (ImGui::BeginPopup("addEntry"))
+            {
+               for (int i = 0; i < sequence->GetItemTypeCount(); i++)
+                  if (ImGui::Selectable(sequence->GetItemTypeName(i)))
+                  {
+                     sequence->Add(i);
+                     *selectedEntry = sequence->GetItemCount() - 1;
+                  }
+
+               ImGui::EndPopup();
+               popupOpened = true;
+            }
+         }
+
+         //header frame number and lines
+         int modFrameCount = 10;
+         int frameStep = 1;
+         while ((modFrameCount * framePixelWidth) < 150)
+         {
+            modFrameCount *= 2;
+            frameStep *= 2;
+         };
+         int halfModFrameCount = modFrameCount / 2;
+
+         auto drawLine = [&](int i, int regionHeight) {
+            bool baseIndex = ((i % modFrameCount) == 0) || (i == sequence->GetFrameMax() || i == sequence->GetFrameMin());
+            bool halfIndex = (i % halfModFrameCount) == 0;
+            int px = (int)canvas_pos.x + int(i * framePixelWidth) + legendWidth - int(firstFrameUsed * framePixelWidth);
+            int tiretStart = baseIndex ? 4 : (halfIndex ? 10 : 14);
+            int tiretEnd = baseIndex ? regionHeight : ItemHeight;
+
+            if (px <= (canvas_size.x + canvas_pos.x) && px >= (canvas_pos.x + legendWidth))
+            {
+               draw_list->AddLine(ImVec2((float)px, canvas_pos.y + (float)tiretStart), ImVec2((float)px, canvas_pos.y + (float)tiretEnd - 1), 0xFF606060, 1);
+
+               draw_list->AddLine(ImVec2((float)px, canvas_pos.y + (float)ItemHeight), ImVec2((float)px, canvas_pos.y + (float)regionHeight - 1), 0x30606060, 1);
+            }
+
+            if (baseIndex && px > (canvas_pos.x + legendWidth))
+            {
+               char tmps[512];
+               ImFormatString(tmps, IM_ARRAYSIZE(tmps), "%d", i);
+               draw_list->AddText(ImVec2((float)px + 3.f, canvas_pos.y), 0xFFBBBBBB, tmps);
+            }
+
+         };
+
+         auto drawLineContent = [&](int i, int /*regionHeight*/) {
+            int px = (int)canvas_pos.x + int(i * framePixelWidth) + legendWidth - int(firstFrameUsed * framePixelWidth);
+            int tiretStart = int(contentMin.y);
+            int tiretEnd = int(contentMax.y);
+
+            if (px <= (canvas_size.x + canvas_pos.x) && px >= (canvas_pos.x + legendWidth))
+            {
+               //draw_list->AddLine(ImVec2((float)px, canvas_pos.y + (float)tiretStart), ImVec2((float)px, canvas_pos.y + (float)tiretEnd - 1), 0xFF606060, 1);
+
+               draw_list->AddLine(ImVec2(float(px), float(tiretStart)), ImVec2(float(px), float(tiretEnd)), 0x30606060, 1);
+            }
+         };
+         for (int i = sequence->GetFrameMin(); i <= sequence->GetFrameMax(); i += frameStep)
+         {
+            drawLine(i, ItemHeight);
+         }
+         drawLine(sequence->GetFrameMin(), ItemHeight);
+         drawLine(sequence->GetFrameMax(), ItemHeight);
+         /*
+                  draw_list->AddLine(canvas_pos, ImVec2(canvas_pos.x, canvas_pos.y + controlHeight), 0xFF000000, 1);
+                  draw_list->AddLine(ImVec2(canvas_pos.x, canvas_pos.y + ItemHeight), ImVec2(canvas_size.x, canvas_pos.y + ItemHeight), 0xFF000000, 1);
+                  */
+                  // clip content
+
+         draw_list->PushClipRect(childFramePos, childFramePos + childFrameSize);
+
+         // draw item names in the legend rect on the left
+         size_t customHeight = 0;
+         for (int i = 0; i < sequenceCount; i++)
+         {
+            int type;
+            sequence->Get(i, NULL, NULL, &type, NULL);
+            ImVec2 tpos(contentMin.x + 3, contentMin.y + i * ItemHeight + 2 + customHeight);
+            draw_list->AddText(tpos, 0xFFFFFFFF, sequence->GetItemLabel(i));
+
+            if (sequenceOptions & SEQUENCER_DEL)
+            {
+               bool overDel = SequencerAddDelButton(draw_list, ImVec2(contentMin.x + legendWidth - ItemHeight + 2 - 10, tpos.y + 2), false);
+               if (overDel && io.MouseReleased[0])
+                  delEntry = i;
+
+               bool overDup = SequencerAddDelButton(draw_list, ImVec2(contentMin.x + legendWidth - ItemHeight - ItemHeight + 2 - 10, tpos.y + 2), true);
+               if (overDup && io.MouseReleased[0])
+                  dupEntry = i;
+            }
+            customHeight += sequence->GetCustomHeight(i);
+         }
+
+         // clipping rect so items bars are not visible in the legend on the left when scrolled
+         //
+
+         // slots background
+         customHeight = 0;
+         for (int i = 0; i < sequenceCount; i++)
+         {
+            unsigned int col = (i & 1) ? 0xFF3A3636 : 0xFF413D3D;
+
+            size_t localCustomHeight = sequence->GetCustomHeight(i);
+            ImVec2 pos = ImVec2(contentMin.x + legendWidth, contentMin.y + ItemHeight * i + 1 + customHeight);
+            ImVec2 sz = ImVec2(canvas_size.x + canvas_pos.x, pos.y + ItemHeight - 1 + localCustomHeight);
+            if (!popupOpened && cy >= pos.y && cy < pos.y + (ItemHeight + localCustomHeight) && movingEntry == -1 && cx>contentMin.x && cx < contentMin.x + canvas_size.x)
+            {
+               col += 0x80201008;
+               pos.x -= legendWidth;
+            }
+            draw_list->AddRectFilled(pos, sz, col, 0);
+            customHeight += localCustomHeight;
+         }
+
+         draw_list->PushClipRect(childFramePos + ImVec2(float(legendWidth), 0.f), childFramePos + childFrameSize);
+
+         // vertical frame lines in content area
+         for (int i = sequence->GetFrameMin(); i <= sequence->GetFrameMax(); i += frameStep)
+         {
+            drawLineContent(i, int(contentHeight));
+         }
+         drawLineContent(sequence->GetFrameMin(), int(contentHeight));
+         drawLineContent(sequence->GetFrameMax(), int(contentHeight));
+
+         // selection
+         bool selected = selectedEntry && (*selectedEntry >= 0);
+         if (selected)
+         {
+            customHeight = 0;
+            for (int i = 0; i < *selectedEntry; i++)
+               customHeight += sequence->GetCustomHeight(i);;
+            draw_list->AddRectFilled(ImVec2(contentMin.x, contentMin.y + ItemHeight * *selectedEntry + customHeight), ImVec2(contentMin.x + canvas_size.x, contentMin.y + ItemHeight * (*selectedEntry + 1) + customHeight), 0x801080FF, 1.f);
+         }
+
+         // slots
+         customHeight = 0;
+         for (int i = 0; i < sequenceCount; i++)
+         {
+            int* start, * end;
+            unsigned int color;
+            sequence->Get(i, &start, &end, NULL, &color);
+            size_t localCustomHeight = sequence->GetCustomHeight(i);
+
+            ImVec2 pos = ImVec2(contentMin.x + legendWidth - firstFrameUsed * framePixelWidth, contentMin.y + ItemHeight * i + 1 + customHeight);
+            ImVec2 slotP1(pos.x + *start * framePixelWidth, pos.y + 2);
+            ImVec2 slotP2(pos.x + *end * framePixelWidth + framePixelWidth, pos.y + ItemHeight - 2);
+            ImVec2 slotP3(pos.x + *end * framePixelWidth + framePixelWidth, pos.y + ItemHeight - 2 + localCustomHeight);
+            unsigned int slotColor = color | 0xFF000000;
+            unsigned int slotColorHalf = (color & 0xFFFFFF) | 0x40000000;
+
+            if (slotP1.x <= (canvas_size.x + contentMin.x) && slotP2.x >= (contentMin.x + legendWidth))
+            {
+               draw_list->AddRectFilled(slotP1, slotP3, slotColorHalf, 2);
+               draw_list->AddRectFilled(slotP1, slotP2, slotColor, 2);
+            }
+            if (ImRect(slotP1, slotP2).Contains(io.MousePos) && io.MouseDoubleClicked[0])
+            {
+               sequence->DoubleClick(i);
+            }
+            // Ensure grabbable handles
+            const float max_handle_width = slotP2.x - slotP1.x / 3.0f;
+            const float min_handle_width = ImMin(10.0f, max_handle_width);
+            const float handle_width = ImClamp(framePixelWidth / 2.0f, min_handle_width, max_handle_width);
+            ImRect rects[3] = { ImRect(slotP1, ImVec2(slotP1.x + handle_width, slotP2.y))
+                , ImRect(ImVec2(slotP2.x - handle_width, slotP1.y), slotP2)
+                , ImRect(slotP1, slotP2) };
+
+            const unsigned int quadColor[] = { 0xFFFFFFFF, 0xFFFFFFFF, slotColor + (selected ? 0 : 0x202020) };
+            if (movingEntry == -1 && (sequenceOptions & SEQUENCER_EDIT_STARTEND))// TODOFOCUS && backgroundRect.Contains(io.MousePos))
+            {
+               for (int j = 2; j >= 0; j--)
+               {
+                  ImRect& rc = rects[j];
+                  if (!rc.Contains(io.MousePos))
+                     continue;
+                  draw_list->AddRectFilled(rc.Min, rc.Max, quadColor[j], 2);
+               }
+
+               for (int j = 0; j < 3; j++)
+               {
+                  ImRect& rc = rects[j];
+                  if (!rc.Contains(io.MousePos))
+                     continue;
+                  if (!ImRect(childFramePos, childFramePos + childFrameSize).Contains(io.MousePos))
+                     continue;
+                  if (ImGui::IsMouseClicked(0) && !MovingScrollBar && !MovingCurrentFrame)
+                  {
+                     movingEntry = i;
+                     movingPos = cx;
+                     movingPart = j + 1;
+                     sequence->BeginEdit(movingEntry);
+                     break;
+                  }
+               }
+            }
+
+            // custom draw
+            if (localCustomHeight > 0)
+            {
+               ImVec2 rp(canvas_pos.x, contentMin.y + ItemHeight * i + 1 + customHeight);
+               ImRect customRect(rp + ImVec2(legendWidth - (firstFrameUsed - sequence->GetFrameMin() - 0.5f) * framePixelWidth, float(ItemHeight)),
+                  rp + ImVec2(legendWidth + (sequence->GetFrameMax() - firstFrameUsed - 0.5f + 2.f) * framePixelWidth, float(localCustomHeight + ItemHeight)));
+               ImRect clippingRect(rp + ImVec2(float(legendWidth), float(ItemHeight)), rp + ImVec2(canvas_size.x, float(localCustomHeight + ItemHeight)));
+
+               ImRect legendRect(rp + ImVec2(0.f, float(ItemHeight)), rp + ImVec2(float(legendWidth), float(localCustomHeight)));
+               ImRect legendClippingRect(canvas_pos + ImVec2(0.f, float(ItemHeight)), canvas_pos + ImVec2(float(legendWidth), float(localCustomHeight + ItemHeight)));
+               customDraws.push_back({ i, customRect, legendRect, clippingRect, legendClippingRect });
+            }
+            else
+            {
+               ImVec2 rp(canvas_pos.x, contentMin.y + ItemHeight * i + customHeight);
+               ImRect customRect(rp + ImVec2(legendWidth - (firstFrameUsed - sequence->GetFrameMin() - 0.5f) * framePixelWidth, float(0.f)),
+                  rp + ImVec2(legendWidth + (sequence->GetFrameMax() - firstFrameUsed - 0.5f + 2.f) * framePixelWidth, float(ItemHeight)));
+               ImRect clippingRect(rp + ImVec2(float(legendWidth), float(0.f)), rp + ImVec2(canvas_size.x, float(ItemHeight)));
+
+               compactCustomDraws.push_back({ i, customRect, ImRect(), clippingRect, ImRect() });
+            }
+            customHeight += localCustomHeight;
+         }
+
+
+         // moving
+         if (/*backgroundRect.Contains(io.MousePos) && */movingEntry >= 0)
+         {
+            ImGui::CaptureMouseFromApp();
+            int diffFrame = int((cx - movingPos) / framePixelWidth);
+            if (std::abs(diffFrame) > 0)
+            {
+               int* start, * end;
+               sequence->Get(movingEntry, &start, &end, NULL, NULL);
+               if (selectedEntry)
+                  *selectedEntry = movingEntry;
+               int& l = *start;
+               int& r = *end;
+               if (movingPart & 1)
+                  l += diffFrame;
+               if (movingPart & 2)
+                  r += diffFrame;
+               if (l < 0)
+               {
+                  if (movingPart & 2)
+                     r -= l;
+                  l = 0;
+               }
+               if (movingPart & 1 && l > r)
+                  l = r;
+               if (movingPart & 2 && r < l)
+                  r = l;
+               movingPos += int(diffFrame * framePixelWidth);
+            }
+            if (!io.MouseDown[0])
+            {
+               // single select
+               if (!diffFrame && movingPart && selectedEntry)
+               {
+                  *selectedEntry = movingEntry;
+                  ret = true;
+               }
+
+               movingEntry = -1;
+               sequence->EndEdit();
+            }
+         }
+
+         // cursor
+         if (currentFrame && firstFrame && *currentFrame >= *firstFrame && *currentFrame <= sequence->GetFrameMax())
+         {
+            static const float cursorWidth = 8.f;
+            float cursorOffset = contentMin.x + legendWidth + (*currentFrame - firstFrameUsed) * framePixelWidth + framePixelWidth / 2 - cursorWidth * 0.5f;
+            draw_list->AddLine(ImVec2(cursorOffset, canvas_pos.y), ImVec2(cursorOffset, contentMax.y), 0xA02A2AFF, cursorWidth);
+            char tmps[512];
+            ImFormatString(tmps, IM_ARRAYSIZE(tmps), "%d", *currentFrame);
+            draw_list->AddText(ImVec2(cursorOffset + 10, canvas_pos.y + 2), 0xFF2A2AFF, tmps);
+         }
+
+         draw_list->PopClipRect();
+         draw_list->PopClipRect();
+
+         for (auto& customDraw : customDraws)
+            sequence->CustomDraw(customDraw.index, draw_list, customDraw.customRect, customDraw.legendRect, customDraw.clippingRect, customDraw.legendClippingRect);
+         for (auto& customDraw : compactCustomDraws)
+            sequence->CustomDrawCompact(customDraw.index, draw_list, customDraw.customRect, customDraw.clippingRect);
+
+         // copy paste
+         if (sequenceOptions & SEQUENCER_COPYPASTE)
+         {
+            ImRect rectCopy(ImVec2(contentMin.x + 100, canvas_pos.y + 2)
+               , ImVec2(contentMin.x + 100 + 30, canvas_pos.y + ItemHeight - 2));
+            bool inRectCopy = rectCopy.Contains(io.MousePos);
+            unsigned int copyColor = inRectCopy ? 0xFF1080FF : 0xFF000000;
+            draw_list->AddText(rectCopy.Min, copyColor, "Copy");
+
+            ImRect rectPaste(ImVec2(contentMin.x + 140, canvas_pos.y + 2)
+               , ImVec2(contentMin.x + 140 + 30, canvas_pos.y + ItemHeight - 2));
+            bool inRectPaste = rectPaste.Contains(io.MousePos);
+            unsigned int pasteColor = inRectPaste ? 0xFF1080FF : 0xFF000000;
+            draw_list->AddText(rectPaste.Min, pasteColor, "Paste");
+
+            if (inRectCopy && io.MouseReleased[0])
+            {
+               sequence->Copy();
+            }
+            if (inRectPaste && io.MouseReleased[0])
+            {
+               sequence->Paste();
+            }
+         }
+         //
+
+         ImGui::EndChildFrame();
+         ImGui::PopStyleColor();
+         if (hasScrollBar)
+         {
+            ImGui::InvisibleButton("scrollBar", scrollBarSize);
+            ImVec2 scrollBarMin = ImGui::GetItemRectMin();
+            ImVec2 scrollBarMax = ImGui::GetItemRectMax();
+
+            // ratio = number of frames visible in control / number to total frames
+
+            float startFrameOffset = ((float)(firstFrameUsed - sequence->GetFrameMin()) / (float)frameCount) * (canvas_size.x - legendWidth);
+            ImVec2 scrollBarA(scrollBarMin.x + legendWidth, scrollBarMin.y - 2);
+            ImVec2 scrollBarB(scrollBarMin.x + canvas_size.x, scrollBarMax.y - 1);
+            draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF222222, 0);
+
+            ImRect scrollBarRect(scrollBarA, scrollBarB);
+            bool inScrollBar = scrollBarRect.Contains(io.MousePos);
+
+            draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF101010, 8);
+
+
+            ImVec2 scrollBarC(scrollBarMin.x + legendWidth + startFrameOffset, scrollBarMin.y);
+            ImVec2 scrollBarD(scrollBarMin.x + legendWidth + barWidthInPixels + startFrameOffset, scrollBarMax.y - 2);
+            draw_list->AddRectFilled(scrollBarC, scrollBarD, (inScrollBar || MovingScrollBar) ? 0xFF606060 : 0xFF505050, 6);
+
+            ImRect barHandleLeft(scrollBarC, ImVec2(scrollBarC.x + 14, scrollBarD.y));
+            ImRect barHandleRight(ImVec2(scrollBarD.x - 14, scrollBarC.y), scrollBarD);
+
+            bool onLeft = barHandleLeft.Contains(io.MousePos);
+            bool onRight = barHandleRight.Contains(io.MousePos);
+
+            static bool sizingRBar = false;
+            static bool sizingLBar = false;
+
+            draw_list->AddRectFilled(barHandleLeft.Min, barHandleLeft.Max, (onLeft || sizingLBar) ? 0xFFAAAAAA : 0xFF666666, 6);
+            draw_list->AddRectFilled(barHandleRight.Min, barHandleRight.Max, (onRight || sizingRBar) ? 0xFFAAAAAA : 0xFF666666, 6);
+
+            ImRect scrollBarThumb(scrollBarC, scrollBarD);
+            static const float MinBarWidth = 44.f;
+            if (sizingRBar)
+            {
+               if (!io.MouseDown[0])
+               {
+                  sizingRBar = false;
+               }
+               else
+               {
+                  float barNewWidth = ImMax(barWidthInPixels + io.MouseDelta.x, MinBarWidth);
+                  float barRatio = barNewWidth / barWidthInPixels;
+                  framePixelWidthTarget = framePixelWidth = framePixelWidth / barRatio;
+                  int newVisibleFrameCount = int((canvas_size.x - legendWidth) / framePixelWidthTarget);
+                  int lastFrame = *firstFrame + newVisibleFrameCount;
+                  if (lastFrame > sequence->GetFrameMax())
+                  {
+                     framePixelWidthTarget = framePixelWidth = (canvas_size.x - legendWidth) / float(sequence->GetFrameMax() - *firstFrame);
+                  }
+               }
+            }
+            else if (sizingLBar)
+            {
+               if (!io.MouseDown[0])
+               {
+                  sizingLBar = false;
+               }
+               else
+               {
+                  if (fabsf(io.MouseDelta.x) > FLT_EPSILON)
+                  {
+                     float barNewWidth = ImMax(barWidthInPixels - io.MouseDelta.x, MinBarWidth);
+                     float barRatio = barNewWidth / barWidthInPixels;
+                     float previousFramePixelWidthTarget = framePixelWidthTarget;
+                     framePixelWidthTarget = framePixelWidth = framePixelWidth / barRatio;
+                     int newVisibleFrameCount = int(visibleFrameCount / barRatio);
+                     int newFirstFrame = *firstFrame + newVisibleFrameCount - visibleFrameCount;
+                     newFirstFrame = ImClamp(newFirstFrame, sequence->GetFrameMin(), ImMax(sequence->GetFrameMax() - visibleFrameCount, sequence->GetFrameMin()));
+                     if (newFirstFrame == *firstFrame)
+                     {
+                        framePixelWidth = framePixelWidthTarget = previousFramePixelWidthTarget;
+                     }
+                     else
+                     {
+                        *firstFrame = newFirstFrame;
+                     }
+                  }
+               }
+            }
+            else
+            {
+               if (MovingScrollBar)
+               {
+                  if (!io.MouseDown[0])
+                  {
+                     MovingScrollBar = false;
+                  }
+                  else
+                  {
+                     float framesPerPixelInBar = barWidthInPixels / (float)visibleFrameCount;
+                     *firstFrame = int((io.MousePos.x - panningViewSource.x) / framesPerPixelInBar) - panningViewFrame;
+                     *firstFrame = ImClamp(*firstFrame, sequence->GetFrameMin(), ImMax(sequence->GetFrameMax() - visibleFrameCount, sequence->GetFrameMin()));
+                  }
+               }
+               else
+               {
+                  if (scrollBarThumb.Contains(io.MousePos) && ImGui::IsMouseClicked(0) && firstFrame && !MovingCurrentFrame && movingEntry == -1)
+                  {
+                     MovingScrollBar = true;
+                     panningViewSource = io.MousePos;
+                     panningViewFrame = -*firstFrame;
+                  }
+                  if (!sizingRBar && onRight && ImGui::IsMouseClicked(0))
+                     sizingRBar = true;
+                  if (!sizingLBar && onLeft && ImGui::IsMouseClicked(0))
+                     sizingLBar = true;
+
+               }
+            }
+         }
+      }
+
+      ImGui::EndGroup();
+
+      if (regionRect.Contains(io.MousePos))
+      {
+         bool overCustomDraw = false;
+         for (auto& custom : customDraws)
+         {
+            if (custom.customRect.Contains(io.MousePos))
+            {
+               overCustomDraw = true;
+            }
+         }
+         if (overCustomDraw)
+         {
+         }
+         else
+         {
+#if 0
+            frameOverCursor = *firstFrame + (int)(visibleFrameCount * ((io.MousePos.x - (float)legendWidth - canvas_pos.x) / (canvas_size.x - legendWidth)));
+            //frameOverCursor = max(min(*firstFrame - visibleFrameCount / 2, frameCount - visibleFrameCount), 0);
+
+            /**firstFrame -= frameOverCursor;
+            *firstFrame *= framePixelWidthTarget / framePixelWidth;
+            *firstFrame += frameOverCursor;*/
+            if (io.MouseWheel < -FLT_EPSILON)
+            {
+               *firstFrame -= frameOverCursor;
+               *firstFrame = int(*firstFrame * 1.1f);
+               framePixelWidthTarget *= 0.9f;
+               *firstFrame += frameOverCursor;
+            }
+
+            if (io.MouseWheel > FLT_EPSILON)
+            {
+               *firstFrame -= frameOverCursor;
+               *firstFrame = int(*firstFrame * 0.9f);
+               framePixelWidthTarget *= 1.1f;
+               *firstFrame += frameOverCursor;
+            }
+#endif
+         }
+      }
+
+      if (expanded)
+      {
+         bool overExpanded = SequencerAddDelButton(draw_list, ImVec2(canvas_pos.x + 2, canvas_pos.y + 2), !*expanded);
+         if (overExpanded && io.MouseReleased[0])
+            *expanded = !*expanded;
+      }
+
+      if (delEntry != -1)
+      {
+         sequence->Del(delEntry);
+         if (selectedEntry && (*selectedEntry == delEntry || *selectedEntry >= sequence->GetItemCount()))
+            *selectedEntry = -1;
+      }
+
+      if (dupEntry != -1)
+      {
+         sequence->Duplicate(dupEntry);
+      }
+      return ret;
+   }
+}

3rdparty/ImGuizmo/ImSequencer.h

@@ -0,0 +1,76 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#pragma once
+
+#include <cstddef>
+
+struct ImDrawList;
+struct ImRect;
+namespace ImSequencer
+{
+   enum SEQUENCER_OPTIONS
+   {
+      SEQUENCER_EDIT_NONE = 0,
+      SEQUENCER_EDIT_STARTEND = 1 << 1,
+      SEQUENCER_CHANGE_FRAME = 1 << 3,
+      SEQUENCER_ADD = 1 << 4,
+      SEQUENCER_DEL = 1 << 5,
+      SEQUENCER_COPYPASTE = 1 << 6,
+      SEQUENCER_EDIT_ALL = SEQUENCER_EDIT_STARTEND | SEQUENCER_CHANGE_FRAME
+   };
+
+   struct SequenceInterface
+   {
+      bool focused = false;
+      virtual int GetFrameMin() const = 0;
+      virtual int GetFrameMax() const = 0;
+      virtual int GetItemCount() const = 0;
+
+      virtual void BeginEdit(int /*index*/) {}
+      virtual void EndEdit() {}
+      virtual int GetItemTypeCount() const { return 0; }
+      virtual const char* GetItemTypeName(int /*typeIndex*/) const { return ""; }
+      virtual const char* GetItemLabel(int /*index*/) const { return ""; }
+
+      virtual void Get(int index, int** start, int** end, int* type, unsigned int* color) = 0;
+      virtual void Add(int /*type*/) {}
+      virtual void Del(int /*index*/) {}
+      virtual void Duplicate(int /*index*/) {}
+
+      virtual void Copy() {}
+      virtual void Paste() {}
+
+      virtual size_t GetCustomHeight(int /*index*/) { return 0; }
+      virtual void DoubleClick(int /*index*/) {}
+      virtual void CustomDraw(int /*index*/, ImDrawList* /*draw_list*/, const ImRect& /*rc*/, const ImRect& /*legendRect*/, const ImRect& /*clippingRect*/, const ImRect& /*legendClippingRect*/) {}
+      virtual void CustomDrawCompact(int /*index*/, ImDrawList* /*draw_list*/, const ImRect& /*rc*/, const ImRect& /*clippingRect*/) {}
+   };
+
+
+   // return true if selection is made
+   bool Sequencer(SequenceInterface* sequence, int* currentFrame, bool* expanded, int* selectedEntry, int* firstFrame, int sequenceOptions);
+
+}

3rdparty/ImGuizmo/ImZoomSlider.h

@@ -0,0 +1,245 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#pragma once
+
+namespace ImZoomSlider
+{
+   typedef int ImGuiZoomSliderFlags;
+   enum ImGuiPopupFlags_
+   {
+      ImGuiZoomSliderFlags_None = 0,
+      ImGuiZoomSliderFlags_Vertical = 1,
+      ImGuiZoomSliderFlags_NoAnchors = 2,
+      ImGuiZoomSliderFlags_NoMiddleCarets = 4,
+      ImGuiZoomSliderFlags_NoWheel = 8,
+   };
+
+   template<typename T> bool ImZoomSlider(const T lower, const T higher, T& viewLower, T& viewHigher, float wheelRatio = 0.01f, ImGuiZoomSliderFlags flags = ImGuiZoomSliderFlags_None)
+   {
+      bool interacted = false;
+      ImGuiIO& io = ImGui::GetIO();
+      ImDrawList* draw_list = ImGui::GetWindowDrawList();
+
+      static const float handleSize = 12;
+      static const float roundRadius = 3.f;
+      static const char* controlName = "ImZoomSlider";
+
+      static bool movingScrollBarSvg = false;
+      static bool sizingRBarSvg = false;
+      static bool sizingLBarSvg = false;
+      static ImGuiID editingId = (ImGuiID)-1;
+      static float scrollingSource = 0.f;
+      static float saveViewLower;
+      static float saveViewHigher;
+
+      const bool isVertical = flags & ImGuiZoomSliderFlags_Vertical;
+      const ImVec2 canvasPos = ImGui::GetCursorScreenPos();
+      const ImVec2 canvasSize = ImGui::GetContentRegionAvail();
+      const float canvasSizeLength = isVertical ? ImGui::GetItemRectSize().y : canvasSize.x;
+      const ImVec2 scrollBarSize = isVertical ? ImVec2(14.f, canvasSizeLength) : ImVec2(canvasSizeLength, 14.f);
+
+      ImGui::InvisibleButton(controlName, scrollBarSize);
+      const ImGuiID currentId = ImGui::GetID(controlName);
+
+      const bool usingEditingId = currentId == editingId;
+      const bool canUseControl = usingEditingId || editingId == -1;
+      const bool movingScrollBar = usingEditingId ? movingScrollBarSvg : false;
+      const bool sizingRBar = usingEditingId ? sizingRBarSvg : false;
+      const bool sizingLBar = usingEditingId ? sizingLBarSvg : false;
+      const int componentIndex = isVertical ? 1 : 0;
+      const ImVec2 scrollBarMin = ImGui::GetItemRectMin();
+      const ImVec2 scrollBarMax = ImGui::GetItemRectMax();
+      const ImVec2 scrollBarA = ImVec2(scrollBarMin.x, scrollBarMin.y) - (isVertical ? ImVec2(2,0) : ImVec2(0,2));
+      const ImVec2 scrollBarB = isVertical ? ImVec2(scrollBarMax.x - 1.f, scrollBarMin.y + canvasSizeLength) : ImVec2(scrollBarMin.x + canvasSizeLength, scrollBarMax.y - 1.f);
+      const float scrollStart = ((viewLower - lower) / (higher - lower)) * canvasSizeLength + scrollBarMin[componentIndex];
+      const float scrollEnd = ((viewHigher - lower) / (higher - lower)) * canvasSizeLength + scrollBarMin[componentIndex];
+      const float screenSize = scrollEnd - scrollStart;
+      const ImVec2 scrollTopLeft = isVertical ? ImVec2(scrollBarMin.x, scrollStart) : ImVec2(scrollStart, scrollBarMin.y);
+      const ImVec2 scrollBottomRight = isVertical ? ImVec2(scrollBarMax.x - 2.f, scrollEnd) : ImVec2(scrollEnd, scrollBarMax.y - 2.f);
+      const bool inScrollBar = canUseControl && ImRect(scrollTopLeft, scrollBottomRight).Contains(io.MousePos);
+      const ImRect scrollBarRect(scrollBarA, scrollBarB);
+      const float deltaScreen = io.MousePos[componentIndex] - scrollingSource;
+      const float deltaView = ((higher - lower) / canvasSizeLength) * deltaScreen;
+      const uint32_t barColor = ImGui::GetColorU32((inScrollBar || movingScrollBar) ? ImGuiCol_FrameBgHovered : ImGuiCol_FrameBg);
+      const float middleCoord = (scrollStart + scrollEnd) * 0.5f;
+      const bool insideControl = canUseControl && ImRect(scrollBarMin, scrollBarMax).Contains(io.MousePos);
+      const bool hasAnchors = !(flags & ImGuiZoomSliderFlags_NoAnchors);
+      const float viewMinSize = ((3.f * handleSize) / canvasSizeLength) * (higher - lower);
+      const auto ClipView = [lower, higher, &viewLower, &viewHigher]() {
+         if (viewLower < lower)
+         {
+            const float deltaClip = lower - viewLower;
+            viewLower += deltaClip;
+            viewHigher += deltaClip;
+         }
+         if (viewHigher > higher)
+         {
+            const float deltaClip = viewHigher - higher;
+            viewLower -= deltaClip;
+            viewHigher -= deltaClip;
+         }
+      };
+
+      bool onLeft = false;
+      bool onRight = false;
+
+      draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF101010, roundRadius);
+      draw_list->AddRectFilled(scrollBarA, scrollBarB, 0xFF222222, 0);
+      draw_list->AddRectFilled(scrollTopLeft, scrollBottomRight, barColor, roundRadius);
+
+      if (!(flags & ImGuiZoomSliderFlags_NoMiddleCarets))
+      {
+         for (float i = 0.5f; i < 3.f; i += 1.f)
+         {
+            const float coordA = middleCoord - handleSize * 0.5f;
+            const float coordB = middleCoord + handleSize * 0.5f;
+            ImVec2 base = scrollBarMin;
+            base.x += scrollBarSize.x * 0.25f * i;
+            base.y += scrollBarSize.y * 0.25f * i;
+
+            if (isVertical)
+            {
+               draw_list->AddLine(ImVec2(base.x, coordA), ImVec2(base.x, coordB), ImGui::GetColorU32(ImGuiCol_SliderGrab));
+            }
+            else
+            {
+               draw_list->AddLine(ImVec2(coordA, base.y), ImVec2(coordB, base.y), ImGui::GetColorU32(ImGuiCol_SliderGrab));
+            }
+         }
+      }
+
+      // Mouse wheel
+      if (io.MouseClicked[0] && insideControl && !inScrollBar)
+      {
+         const float ratio = (io.MousePos[componentIndex] - scrollBarMin[componentIndex]) / (scrollBarMax[componentIndex] - scrollBarMin[componentIndex]);
+         const float size = (higher - lower);
+         const float halfViewSize = (viewHigher - viewLower) * 0.5f;
+         const float middle = ratio * size + lower;
+         viewLower = middle - halfViewSize;
+         viewHigher = middle + halfViewSize;
+         ClipView();
+         interacted = true;
+      }
+
+      if (!(flags & ImGuiZoomSliderFlags_NoWheel) && inScrollBar && fabsf(io.MouseWheel) > 0.f)
+      {
+         const float ratio = (io.MousePos[componentIndex] - scrollStart) / (scrollEnd - scrollStart);
+         const float amount = io.MouseWheel * wheelRatio * (viewHigher - viewLower);
+         
+         viewLower -= ratio * amount;
+         viewHigher += (1.f - ratio) * amount;
+         ClipView();
+         interacted = true;
+      }
+
+      if (screenSize > handleSize * 2.f && hasAnchors)
+      {
+         const ImRect barHandleLeft(scrollTopLeft, isVertical ? ImVec2(scrollBottomRight.x, scrollTopLeft.y + handleSize) : ImVec2(scrollTopLeft.x + handleSize, scrollBottomRight.y));
+         const ImRect barHandleRight(isVertical ? ImVec2(scrollTopLeft.x, scrollBottomRight.y - handleSize) : ImVec2(scrollBottomRight.x - handleSize, scrollTopLeft.y), scrollBottomRight);
+
+         onLeft = barHandleLeft.Contains(io.MousePos);
+         onRight = barHandleRight.Contains(io.MousePos);
+
+         draw_list->AddRectFilled(barHandleLeft.Min, barHandleLeft.Max, ImGui::GetColorU32((onLeft || sizingLBar) ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), roundRadius);
+         draw_list->AddRectFilled(barHandleRight.Min, barHandleRight.Max, ImGui::GetColorU32((onRight || sizingRBar) ? ImGuiCol_SliderGrabActive : ImGuiCol_SliderGrab), roundRadius);
+      }
+
+      if (sizingRBar)
+      {
+         if (!io.MouseDown[0])
+         {
+            sizingRBarSvg = false;
+            editingId = (ImGuiID)-1;
+         }
+         else
+         {
+            viewHigher = ImMin(saveViewHigher + deltaView, higher);
+         }
+      }
+      else if (sizingLBar)
+      {
+         if (!io.MouseDown[0])
+         {
+            sizingLBarSvg = false;
+            editingId = (ImGuiID)-1;
+         }
+         else
+         {
+            viewLower = ImMax(saveViewLower + deltaView, lower);
+         }
+      }
+      else
+      {
+         if (movingScrollBar)
+         {
+            if (!io.MouseDown[0])
+            {
+               movingScrollBarSvg = false;
+               editingId = (ImGuiID)-1;
+            }
+            else
+            {
+               viewLower = saveViewLower + deltaView;
+               viewHigher = saveViewHigher + deltaView;
+               ClipView();
+            }
+         }
+         else
+         {
+            if (inScrollBar && ImGui::IsMouseClicked(0))
+            {
+               movingScrollBarSvg = true;
+               scrollingSource = io.MousePos[componentIndex];
+               saveViewLower = viewLower;
+               saveViewHigher = viewHigher;
+               editingId = currentId;
+            }
+            if (!sizingRBar && onRight && ImGui::IsMouseClicked(0) && hasAnchors)
+            {
+               sizingRBarSvg = true;
+               editingId = currentId;
+            }
+            if (!sizingLBar && onLeft && ImGui::IsMouseClicked(0) && hasAnchors)
+            {
+               sizingLBarSvg = true;
+               editingId = currentId;
+            }
+         }
+      }
+
+      // minimal size check
+      if ((viewHigher - viewLower) < viewMinSize)
+      {
+         const float middle = (viewLower + viewHigher) * 0.5f;
+         viewLower = middle - viewMinSize * 0.5f;
+         viewHigher = middle + viewMinSize * 0.5f;
+         ClipView();
+      }
+
+      return movingScrollBar || sizingRBar || sizingLBar || interacted;
+   }
+
+} // namespace

3rdparty/ImGuizmo/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Cedric Guillemet
+
+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 of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS 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.

3rdparty/ImGuizmo/Makefile

@@ -0,0 +1,19 @@
+CXXFLAGS=-std=c++11
+CPPFLAGS=-I. -Iexample
+
+LIB_OBJS = ImGuizmo.o GraphEditor.o ImCurveEdit.o ImGradient.o ImSequencer.o
+EXAMPLE_OBJS = example/imgui.o example/imgui_draw.o example/imgui_tables.o example/imgui_widgets.o example/main.o
+
+EXAMPLE_NAME = example.exe
+LDFLAGS=-mwindows -static-libgcc -static-libstdc++
+LIBS=-limm32 -lopengl32 -lgdi32
+
+$(EXAMPLE_NAME): $(LIB_OBJS) $(EXAMPLE_OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $^ $(LIBS)
+
+example/main.o: CXXFLAGS := -std=c++17
+
+clean:
+	$(RM) $(LIB_OBJS)
+	$(RM) $(EXAMPLE_OBJS)
+	$(RM) $(EXAMPLE_NAME)

3rdparty/ImGuizmo/README.md

@@ -0,0 +1,192 @@
+# ImGuizmo
+
+Latest stable tagged version is 1.83. Current master version is 1.84 WIP.
+
+What started with the gizmo is now a collection of dear imgui widgets and more advanced controls.
+
+## Guizmos
+
+### ImViewGizmo
+
+Manipulate view orientation with 1 single line of code
+
+![Image of ImViewGizmo](http://i.imgur.com/7UVcyDd.gif)
+
+### ImGuizmo
+
+ImGizmo is a small (.h and .cpp) library built ontop of Dear ImGui that allow you to manipulate(Rotate & translate at the moment) 4x4 float matrices. No other dependancies. Coded with Immediate Mode (IM) philosophy in mind.
+
+Built against DearImgui 1.53WIP
+
+![Image of Rotation](http://i.imgur.com/y4mcVoT.gif)
+![Image of Translation](http://i.imgur.com/o8q8iHq.gif)
+![Image of Bounds](http://i.imgur.com/3Ez5LBr.gif)
+
+There is now a sample for Win32/OpenGL ! With a binary in bin directory.
+![Image of Sample](https://i.imgur.com/nXlzyqD.png)
+
+### ImSequencer
+
+A WIP little sequencer used to edit frame start/end for different events in a timeline.
+![Image of Rotation](http://i.imgur.com/BeyNwCn.png)
+Check the sample for the documentation. More to come...
+
+### Graph Editor
+
+Nodes + connections. Custom draw inside nodes is possible with the delegate system in place.
+![Image of GraphEditor](Images/nodeeditor.jpg)
+
+### API doc
+
+Call BeginFrame right after ImGui_XXXX_NewFrame();
+
+```C++
+void BeginFrame();
+```
+
+return true if mouse cursor is over any gizmo control (axis, plan or screen component)
+
+```C++
+bool IsOver();**
+```
+
+return true if mouse IsOver or if the gizmo is in moving state
+
+```C++
+bool IsUsing();**
+```
+
+enable/disable the gizmo. Stay in the state until next call to Enable. gizmo is rendered with gray half transparent color when disabled
+
+```C++
+void Enable(bool enable);**
+```
+
+helper functions for manualy editing translation/rotation/scale with an input float
+translation, rotation and scale float points to 3 floats each
+Angles are in degrees (more suitable for human editing)
+example:
+
+```C++
+ float matrixTranslation[3], matrixRotation[3], matrixScale[3];
+ ImGuizmo::DecomposeMatrixToComponents(gizmoMatrix.m16, matrixTranslation, matrixRotation, matrixScale);
+ ImGui::InputFloat3("Tr", matrixTranslation, 3);
+ ImGui::InputFloat3("Rt", matrixRotation, 3);
+ ImGui::InputFloat3("Sc", matrixScale, 3);
+ ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, gizmoMatrix.m16);
+```
+
+These functions have some numerical stability issues for now. Use with caution.
+
+```C++
+void DecomposeMatrixToComponents(const float *matrix, float *translation, float *rotation, float *scale);
+void RecomposeMatrixFromComponents(const float *translation, const float *rotation, const float *scale, float *matrix);**
+```
+
+Render a cube with face color corresponding to face normal. Usefull for debug/test
+
+```C++
+void DrawCube(const float *view, const float *projection, float *matrix);**
+```
+
+Call it when you want a gizmo
+Needs view and projection matrices.
+Matrix parameter is the source matrix (where will be gizmo be drawn) and might be transformed by the function. Return deltaMatrix is optional. snap points to a float[3] for translation and to a single float for scale or rotation. Snap angle is in Euler Degrees.
+
+```C++
+    enum OPERATION
+    {
+        TRANSLATE,
+        ROTATE,
+        SCALE
+    };
+
+    enum MODE
+    {
+        LOCAL,
+        WORLD
+    };
+
+void Manipulate(const float *view, const float *projection, OPERATION operation, MODE mode, float *matrix, float *deltaMatrix = 0, float *snap = 0);**
+```
+
+### ImGui Example
+
+Code for :
+
+![Image of dialog](http://i.imgur.com/GL5flN1.png)
+
+```C++
+void EditTransform(const Camera& camera, matrix_t& matrix)
+{
+    static ImGuizmo::OPERATION mCurrentGizmoOperation(ImGuizmo::ROTATE);
+    static ImGuizmo::MODE mCurrentGizmoMode(ImGuizmo::WORLD);
+    if (ImGui::IsKeyPressed(90))
+        mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+    if (ImGui::IsKeyPressed(69))
+        mCurrentGizmoOperation = ImGuizmo::ROTATE;
+    if (ImGui::IsKeyPressed(82)) // r Key
+        mCurrentGizmoOperation = ImGuizmo::SCALE;
+    if (ImGui::RadioButton("Translate", mCurrentGizmoOperation == ImGuizmo::TRANSLATE))
+        mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+    ImGui::SameLine();
+    if (ImGui::RadioButton("Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE))
+        mCurrentGizmoOperation = ImGuizmo::ROTATE;
+    ImGui::SameLine();
+    if (ImGui::RadioButton("Scale", mCurrentGizmoOperation == ImGuizmo::SCALE))
+        mCurrentGizmoOperation = ImGuizmo::SCALE;
+    float matrixTranslation[3], matrixRotation[3], matrixScale[3];
+    ImGuizmo::DecomposeMatrixToComponents(matrix.m16, matrixTranslation, matrixRotation, matrixScale);
+    ImGui::InputFloat3("Tr", matrixTranslation, 3);
+    ImGui::InputFloat3("Rt", matrixRotation, 3);
+    ImGui::InputFloat3("Sc", matrixScale, 3);
+    ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, matrix.m16);
+
+    if (mCurrentGizmoOperation != ImGuizmo::SCALE)
+    {
+        if (ImGui::RadioButton("Local", mCurrentGizmoMode == ImGuizmo::LOCAL))
+            mCurrentGizmoMode = ImGuizmo::LOCAL;
+        ImGui::SameLine();
+        if (ImGui::RadioButton("World", mCurrentGizmoMode == ImGuizmo::WORLD))
+            mCurrentGizmoMode = ImGuizmo::WORLD;
+    }
+    static bool useSnap(false);
+    if (ImGui::IsKeyPressed(83))
+        useSnap = !useSnap;
+    ImGui::Checkbox("", &useSnap);
+    ImGui::SameLine();
+    vec_t snap;
+    switch (mCurrentGizmoOperation)
+    {
+    case ImGuizmo::TRANSLATE:
+        snap = config.mSnapTranslation;
+        ImGui::InputFloat3("Snap", &snap.x);
+        break;
+    case ImGuizmo::ROTATE:
+        snap = config.mSnapRotation;
+        ImGui::InputFloat("Angle Snap", &snap.x);
+        break;
+    case ImGuizmo::SCALE:
+        snap = config.mSnapScale;
+        ImGui::InputFloat("Scale Snap", &snap.x);
+        break;
+    }
+    ImGuiIO& io = ImGui::GetIO();
+    ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);
+    ImGuizmo::Manipulate(camera.mView.m16, camera.mProjection.m16, mCurrentGizmoOperation, mCurrentGizmoMode, matrix.m16, NULL, useSnap ? &snap.x : NULL);
+}
+```
+
+## Install
+
+ImGuizmo can be installed via [vcpkg](https://github.com/microsoft/vcpkg) and used cmake
+
+```bash
+vcpkg install vcpkg
+```
+
+See the [vcpkg example](/vcpkg-example) for more details
+
+## License
+
+ImGuizmo is licensed under the MIT License, see [LICENSE](/LICENSE) for more information.

3rdparty/ImGuizmo/bin/imgui.ini

@@ -0,0 +1,25 @@
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Editor]
+Pos=10,10
+Size=320,340
+Collapsed=0
+
+[Window][Gizmo]
+Pos=400,20
+Size=800,400
+Collapsed=0
+
+[Window][Graph Editor]
+Pos=981,294
+Size=787,580
+Collapsed=0
+
+[Window][Other controls]
+Pos=10,350
+Size=693,395
+Collapsed=0
+

3rdparty/ImGuizmo/example/ImGuizmoSample.vcxproj

@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{A7359EC9-7DB5-44A1-91A5-38F499DA6D23}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>ImGuizmoSample</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.17134.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\;.</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>.\;..\</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\;.</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>.\;..\</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\GraphEditor.h" />
+    <ClInclude Include="..\ImCurveEdit.h" />
+    <ClInclude Include="..\ImGradient.h" />
+    <ClInclude Include="..\ImGuizmo.h" />
+    <ClInclude Include="..\ImSequencer.h" />
+    <ClInclude Include="..\ImZoomSlider.h" />
+    <ClInclude Include="ImApp.h" />
+    <ClInclude Include="imconfig.h" />
+    <ClInclude Include="imgui.h" />
+    <ClInclude Include="imgui_internal.h" />
+    <ClInclude Include="stb_image.h" />
+    <ClInclude Include="stb_rect_pack.h" />
+    <ClInclude Include="stb_textedit.h" />
+    <ClInclude Include="stb_truetype.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\GraphEditor.cpp" />
+    <ClCompile Include="..\ImCurveEdit.cpp" />
+    <ClCompile Include="..\ImGradient.cpp" />
+    <ClCompile Include="..\ImGuizmo.cpp" />
+    <ClCompile Include="..\ImSequencer.cpp" />
+    <ClCompile Include="imgui.cpp" />
+    <ClCompile Include="imgui_demo.cpp" />
+    <ClCompile Include="imgui_draw.cpp" />
+    <ClCompile Include="imgui_tables.cpp" />
+    <ClCompile Include="imgui_widgets.cpp" />
+    <ClCompile Include="main.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/ImGuizmo/example/imconfig.h

@@ -0,0 +1,123 @@
+//-----------------------------------------------------------------------------
+// COMPILE-TIME OPTIONS FOR DEAR IMGUI
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
+// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
+//-----------------------------------------------------------------------------
+// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
+// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
+// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Disable all of Dear ImGui or don't implement standard windows.
+// It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
+//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
+//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable metrics/debugger window: ShowMetricsWindow() will be empty.
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
+//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
+//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, ime).
+//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
+//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
+//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
+//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
+//#define IMGUI_USE_WCHAR32
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+
+//---- Use stb_printf's faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
+// Requires 'stb_sprintf.h' to be available in the include path. Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
+// #define IMGUI_USE_STB_SPRINTF
+
+//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
+// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
+//#define IMGUI_ENABLE_FREETYPE
+
+//---- Use stb_truetype to build and rasterize the font atlas (default)
+// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
+//#define IMGUI_ENABLE_STB_TRUETYPE
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                 \
+        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                 \
+        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
+// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
+// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
+// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
+//#define ImDrawIdx unsigned int
+
+//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
+//struct ImDrawList;
+//struct ImDrawCmd;
+//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
+//#define ImDrawCallback MyImDrawCallback
+
+//---- Debug Tools: Macro to break in Debugger
+// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
+//#define IM_DEBUG_BREAK  IM_ASSERT(0)
+//#define IM_DEBUG_BREAK  __debugbreak()
+
+//---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(),
+// (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.)
+// This adds a small runtime cost which is why it is not enabled by default.
+//#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
+
+//---- Debug Tools: Enable slower asserts
+//#define IMGUI_DEBUG_PARANOID
+
+//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, const MyMatrix44& v);
+}
+*/

3rdparty/ImGuizmo/example/imstb_rectpack.h

@@ -0,0 +1,639 @@
+// [DEAR IMGUI]
+// This is a slightly modified version of stb_rect_pack.h 1.00.
+// Those changes would need to be pushed into nothings/stb:
+// - Added STBRP__CDECL
+// Grep for [DEAR IMGUI] to find the changes.
+
+// stb_rect_pack.h - v1.00 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+typedef int            stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+// [DEAR IMGUI] Added STBRP__CDECL
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+#ifndef STBRP_LARGE_RECTS
+   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+#ifdef STBRP_LARGE_RECTS
+   context->extra[1].y = (1<<30);
+#else
+   context->extra[1].y = 65535;
+#endif
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height <= c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  STBRP_ASSERT(y <= best_y);
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL  0xffffffff
+#else
+#define STBRP__MAXVAL  0xffff
+#endif
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+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 THE
+AUTHORS OR COPYRIGHT HOLDERS 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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+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 THE
+AUTHORS 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.
+------------------------------------------------------------------------------
+*/

3rdparty/ImGuizmo/example/main.cpp

@@ -0,0 +1,912 @@
+// https://github.com/CedricGuillemet/ImGuizmo
+// v 1.84 WIP
+//
+// The MIT License(MIT)
+//
+// Copyright(c) 2021 Cedric Guillemet
+//
+// 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 of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// 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 THE
+// AUTHORS OR COPYRIGHT HOLDERS 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.
+//
+#include "imgui.h"
+#define IMGUI_DEFINE_MATH_OPERATORS
+#include "imgui_internal.h"
+#define IMAPP_IMPL
+#include "ImApp.h"
+
+#include "ImGuizmo.h"
+#include "ImSequencer.h"
+#include "ImZoomSlider.h"
+#include "ImCurveEdit.h"
+#include "GraphEditor.h"
+#include <math.h>
+#include <vector>
+#include <algorithm>
+
+bool useWindow = true;
+int gizmoCount = 1;
+float camDistance = 8.f;
+static ImGuizmo::OPERATION mCurrentGizmoOperation(ImGuizmo::TRANSLATE);
+
+float objectMatrix[4][16] = {
+  { 1.f, 0.f, 0.f, 0.f,
+    0.f, 1.f, 0.f, 0.f,
+    0.f, 0.f, 1.f, 0.f,
+    0.f, 0.f, 0.f, 1.f },
+
+  { 1.f, 0.f, 0.f, 0.f,
+  0.f, 1.f, 0.f, 0.f,
+  0.f, 0.f, 1.f, 0.f,
+  2.f, 0.f, 0.f, 1.f },
+
+  { 1.f, 0.f, 0.f, 0.f,
+  0.f, 1.f, 0.f, 0.f,
+  0.f, 0.f, 1.f, 0.f,
+  2.f, 0.f, 2.f, 1.f },
+
+  { 1.f, 0.f, 0.f, 0.f,
+  0.f, 1.f, 0.f, 0.f,
+  0.f, 0.f, 1.f, 0.f,
+  0.f, 0.f, 2.f, 1.f }
+};
+
+static const float identityMatrix[16] =
+{ 1.f, 0.f, 0.f, 0.f,
+    0.f, 1.f, 0.f, 0.f,
+    0.f, 0.f, 1.f, 0.f,
+    0.f, 0.f, 0.f, 1.f };
+
+void Frustum(float left, float right, float bottom, float top, float znear, float zfar, float* m16)
+{
+   float temp, temp2, temp3, temp4;
+   temp = 2.0f * znear;
+   temp2 = right - left;
+   temp3 = top - bottom;
+   temp4 = zfar - znear;
+   m16[0] = temp / temp2;
+   m16[1] = 0.0;
+   m16[2] = 0.0;
+   m16[3] = 0.0;
+   m16[4] = 0.0;
+   m16[5] = temp / temp3;
+   m16[6] = 0.0;
+   m16[7] = 0.0;
+   m16[8] = (right + left) / temp2;
+   m16[9] = (top + bottom) / temp3;
+   m16[10] = (-zfar - znear) / temp4;
+   m16[11] = -1.0f;
+   m16[12] = 0.0;
+   m16[13] = 0.0;
+   m16[14] = (-temp * zfar) / temp4;
+   m16[15] = 0.0;
+}
+
+void Perspective(float fovyInDegrees, float aspectRatio, float znear, float zfar, float* m16)
+{
+   float ymax, xmax;
+   ymax = znear * tanf(fovyInDegrees * 3.141592f / 180.0f);
+   xmax = ymax * aspectRatio;
+   Frustum(-xmax, xmax, -ymax, ymax, znear, zfar, m16);
+}
+
+void Cross(const float* a, const float* b, float* r)
+{
+   r[0] = a[1] * b[2] - a[2] * b[1];
+   r[1] = a[2] * b[0] - a[0] * b[2];
+   r[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+float Dot(const float* a, const float* b)
+{
+   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+void Normalize(const float* a, float* r)
+{
+   float il = 1.f / (sqrtf(Dot(a, a)) + FLT_EPSILON);
+   r[0] = a[0] * il;
+   r[1] = a[1] * il;
+   r[2] = a[2] * il;
+}
+
+void LookAt(const float* eye, const float* at, const float* up, float* m16)
+{
+   float X[3], Y[3], Z[3], tmp[3];
+
+   tmp[0] = eye[0] - at[0];
+   tmp[1] = eye[1] - at[1];
+   tmp[2] = eye[2] - at[2];
+   Normalize(tmp, Z);
+   Normalize(up, Y);
+
+   Cross(Y, Z, tmp);
+   Normalize(tmp, X);
+
+   Cross(Z, X, tmp);
+   Normalize(tmp, Y);
+
+   m16[0] = X[0];
+   m16[1] = Y[0];
+   m16[2] = Z[0];
+   m16[3] = 0.0f;
+   m16[4] = X[1];
+   m16[5] = Y[1];
+   m16[6] = Z[1];
+   m16[7] = 0.0f;
+   m16[8] = X[2];
+   m16[9] = Y[2];
+   m16[10] = Z[2];
+   m16[11] = 0.0f;
+   m16[12] = -Dot(X, eye);
+   m16[13] = -Dot(Y, eye);
+   m16[14] = -Dot(Z, eye);
+   m16[15] = 1.0f;
+}
+
+void OrthoGraphic(const float l, float r, float b, const float t, float zn, const float zf, float* m16)
+{
+   m16[0] = 2 / (r - l);
+   m16[1] = 0.0f;
+   m16[2] = 0.0f;
+   m16[3] = 0.0f;
+   m16[4] = 0.0f;
+   m16[5] = 2 / (t - b);
+   m16[6] = 0.0f;
+   m16[7] = 0.0f;
+   m16[8] = 0.0f;
+   m16[9] = 0.0f;
+   m16[10] = 1.0f / (zf - zn);
+   m16[11] = 0.0f;
+   m16[12] = (l + r) / (l - r);
+   m16[13] = (t + b) / (b - t);
+   m16[14] = zn / (zn - zf);
+   m16[15] = 1.0f;
+}
+
+inline void rotationY(const float angle, float* m16)
+{
+   float c = cosf(angle);
+   float s = sinf(angle);
+
+   m16[0] = c;
+   m16[1] = 0.0f;
+   m16[2] = -s;
+   m16[3] = 0.0f;
+   m16[4] = 0.0f;
+   m16[5] = 1.f;
+   m16[6] = 0.0f;
+   m16[7] = 0.0f;
+   m16[8] = s;
+   m16[9] = 0.0f;
+   m16[10] = c;
+   m16[11] = 0.0f;
+   m16[12] = 0.f;
+   m16[13] = 0.f;
+   m16[14] = 0.f;
+   m16[15] = 1.0f;
+}
+
+void EditTransform(float* cameraView, float* cameraProjection, float* matrix, bool editTransformDecomposition)
+{
+   static ImGuizmo::MODE mCurrentGizmoMode(ImGuizmo::LOCAL);
+   static bool useSnap = false;
+   static float snap[3] = { 1.f, 1.f, 1.f };
+   static float bounds[] = { -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, 0.5f };
+   static float boundsSnap[] = { 0.1f, 0.1f, 0.1f };
+   static bool boundSizing = false;
+   static bool boundSizingSnap = false;
+
+   if (editTransformDecomposition)
+   {
+      if (ImGui::IsKeyPressed(90))
+         mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+      if (ImGui::IsKeyPressed(69))
+         mCurrentGizmoOperation = ImGuizmo::ROTATE;
+      if (ImGui::IsKeyPressed(82)) // r Key
+         mCurrentGizmoOperation = ImGuizmo::SCALE;
+      if (ImGui::RadioButton("Translate", mCurrentGizmoOperation == ImGuizmo::TRANSLATE))
+         mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE))
+         mCurrentGizmoOperation = ImGuizmo::ROTATE;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Scale", mCurrentGizmoOperation == ImGuizmo::SCALE))
+         mCurrentGizmoOperation = ImGuizmo::SCALE;
+      if (ImGui::RadioButton("Universal", mCurrentGizmoOperation == ImGuizmo::UNIVERSAL))
+         mCurrentGizmoOperation = ImGuizmo::UNIVERSAL;
+      float matrixTranslation[3], matrixRotation[3], matrixScale[3];
+      ImGuizmo::DecomposeMatrixToComponents(matrix, matrixTranslation, matrixRotation, matrixScale);
+      ImGui::InputFloat3("Tr", matrixTranslation);
+      ImGui::InputFloat3("Rt", matrixRotation);
+      ImGui::InputFloat3("Sc", matrixScale);
+      ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, matrix);
+
+      if (mCurrentGizmoOperation != ImGuizmo::SCALE)
+      {
+         if (ImGui::RadioButton("Local", mCurrentGizmoMode == ImGuizmo::LOCAL))
+            mCurrentGizmoMode = ImGuizmo::LOCAL;
+         ImGui::SameLine();
+         if (ImGui::RadioButton("World", mCurrentGizmoMode == ImGuizmo::WORLD))
+            mCurrentGizmoMode = ImGuizmo::WORLD;
+      }
+      if (ImGui::IsKeyPressed(83))
+         useSnap = !useSnap;
+      ImGui::Checkbox("", &useSnap);
+      ImGui::SameLine();
+
+      switch (mCurrentGizmoOperation)
+      {
+      case ImGuizmo::TRANSLATE:
+         ImGui::InputFloat3("Snap", &snap[0]);
+         break;
+      case ImGuizmo::ROTATE:
+         ImGui::InputFloat("Angle Snap", &snap[0]);
+         break;
+      case ImGuizmo::SCALE:
+         ImGui::InputFloat("Scale Snap", &snap[0]);
+         break;
+      }
+      ImGui::Checkbox("Bound Sizing", &boundSizing);
+      if (boundSizing)
+      {
+         ImGui::PushID(3);
+         ImGui::Checkbox("", &boundSizingSnap);
+         ImGui::SameLine();
+         ImGui::InputFloat3("Snap", boundsSnap);
+         ImGui::PopID();
+      }
+   }
+
+   ImGuiIO& io = ImGui::GetIO();
+   float viewManipulateRight = io.DisplaySize.x;
+   float viewManipulateTop = 0;
+   if (useWindow)
+   {
+      ImGui::SetNextWindowSize(ImVec2(800, 400));
+      ImGui::SetNextWindowPos(ImVec2(400,20));
+      ImGui::PushStyleColor(ImGuiCol_WindowBg, (ImVec4)ImColor(0.35f, 0.3f, 0.3f));
+      ImGui::Begin("Gizmo", 0, ImGuiWindowFlags_NoMove);
+      ImGuizmo::SetDrawlist();
+      float windowWidth = (float)ImGui::GetWindowWidth();
+      float windowHeight = (float)ImGui::GetWindowHeight();
+      ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, windowWidth, windowHeight);
+      viewManipulateRight = ImGui::GetWindowPos().x + windowWidth;
+      viewManipulateTop = ImGui::GetWindowPos().y;
+   }
+   else
+   {
+      ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);
+   }
+
+   ImGuizmo::DrawGrid(cameraView, cameraProjection, identityMatrix, 100.f);
+   ImGuizmo::DrawCubes(cameraView, cameraProjection, &objectMatrix[0][0], gizmoCount);
+   ImGuizmo::Manipulate(cameraView, cameraProjection, mCurrentGizmoOperation, mCurrentGizmoMode, matrix, NULL, useSnap ? &snap[0] : NULL, boundSizing ? bounds : NULL, boundSizingSnap ? boundsSnap : NULL);
+
+   ImGuizmo::ViewManipulate(cameraView, camDistance, ImVec2(viewManipulateRight - 128, viewManipulateTop), ImVec2(128, 128), 0x10101010);
+
+   if (useWindow)
+   {
+      ImGui::End();
+      ImGui::PopStyleColor(1);
+   }
+}
+
+//
+//
+// ImSequencer interface
+//
+//
+static const char* SequencerItemTypeNames[] = { "Camera","Music", "ScreenEffect", "FadeIn", "Animation" };
+
+struct RampEdit : public ImCurveEdit::Delegate
+{
+   RampEdit()
+   {
+      mPts[0][0] = ImVec2(-10.f, 0);
+      mPts[0][1] = ImVec2(20.f, 0.6f);
+      mPts[0][2] = ImVec2(25.f, 0.2f);
+      mPts[0][3] = ImVec2(70.f, 0.4f);
+      mPts[0][4] = ImVec2(120.f, 1.f);
+      mPointCount[0] = 5;
+
+      mPts[1][0] = ImVec2(-50.f, 0.2f);
+      mPts[1][1] = ImVec2(33.f, 0.7f);
+      mPts[1][2] = ImVec2(80.f, 0.2f);
+      mPts[1][3] = ImVec2(82.f, 0.8f);
+      mPointCount[1] = 4;
+
+
+      mPts[2][0] = ImVec2(40.f, 0);
+      mPts[2][1] = ImVec2(60.f, 0.1f);
+      mPts[2][2] = ImVec2(90.f, 0.82f);
+      mPts[2][3] = ImVec2(150.f, 0.24f);
+      mPts[2][4] = ImVec2(200.f, 0.34f);
+      mPts[2][5] = ImVec2(250.f, 0.12f);
+      mPointCount[2] = 6;
+      mbVisible[0] = mbVisible[1] = mbVisible[2] = true;
+      mMax = ImVec2(1.f, 1.f);
+      mMin = ImVec2(0.f, 0.f);
+   }
+   size_t GetCurveCount()
+   {
+      return 3;
+   }
+
+   bool IsVisible(size_t curveIndex)
+   {
+      return mbVisible[curveIndex];
+   }
+   size_t GetPointCount(size_t curveIndex)
+   {
+      return mPointCount[curveIndex];
+   }
+
+   uint32_t GetCurveColor(size_t curveIndex)
+   {
+      uint32_t cols[] = { 0xFF0000FF, 0xFF00FF00, 0xFFFF0000 };
+      return cols[curveIndex];
+   }
+   ImVec2* GetPoints(size_t curveIndex)
+   {
+      return mPts[curveIndex];
+   }
+   virtual ImCurveEdit::CurveType GetCurveType(size_t curveIndex) const { return ImCurveEdit::CurveSmooth; }
+   virtual int EditPoint(size_t curveIndex, int pointIndex, ImVec2 value)
+   {
+      mPts[curveIndex][pointIndex] = ImVec2(value.x, value.y);
+      SortValues(curveIndex);
+      for (size_t i = 0; i < GetPointCount(curveIndex); i++)
+      {
+         if (mPts[curveIndex][i].x == value.x)
+            return (int)i;
+      }
+      return pointIndex;
+   }
+   virtual void AddPoint(size_t curveIndex, ImVec2 value)
+   {
+      if (mPointCount[curveIndex] >= 8)
+         return;
+      mPts[curveIndex][mPointCount[curveIndex]++] = value;
+      SortValues(curveIndex);
+   }
+   virtual ImVec2& GetMax() { return mMax; }
+   virtual ImVec2& GetMin() { return mMin; }
+   virtual unsigned int GetBackgroundColor() { return 0; }
+   ImVec2 mPts[3][8];
+   size_t mPointCount[3];
+   bool mbVisible[3];
+   ImVec2 mMin;
+   ImVec2 mMax;
+private:
+   void SortValues(size_t curveIndex)
+   {
+      auto b = std::begin(mPts[curveIndex]);
+      auto e = std::begin(mPts[curveIndex]) + GetPointCount(curveIndex);
+      std::sort(b, e, [](ImVec2 a, ImVec2 b) { return a.x < b.x; });
+
+   }
+};
+
+struct MySequence : public ImSequencer::SequenceInterface
+{
+   // interface with sequencer
+
+   virtual int GetFrameMin() const {
+      return mFrameMin;
+   }
+   virtual int GetFrameMax() const {
+      return mFrameMax;
+   }
+   virtual int GetItemCount() const { return (int)myItems.size(); }
+
+   virtual int GetItemTypeCount() const { return sizeof(SequencerItemTypeNames) / sizeof(char*); }
+   virtual const char* GetItemTypeName(int typeIndex) const { return SequencerItemTypeNames[typeIndex]; }
+   virtual const char* GetItemLabel(int index) const
+   {
+      static char tmps[512];
+      snprintf(tmps, 512, "[%02d] %s", index, SequencerItemTypeNames[myItems[index].mType]);
+      return tmps;
+   }
+
+   virtual void Get(int index, int** start, int** end, int* type, unsigned int* color)
+   {
+      MySequenceItem& item = myItems[index];
+      if (color)
+         *color = 0xFFAA8080; // same color for everyone, return color based on type
+      if (start)
+         *start = &item.mFrameStart;
+      if (end)
+         *end = &item.mFrameEnd;
+      if (type)
+         *type = item.mType;
+   }
+   virtual void Add(int type) { myItems.push_back(MySequenceItem{ type, 0, 10, false }); };
+   virtual void Del(int index) { myItems.erase(myItems.begin() + index); }
+   virtual void Duplicate(int index) { myItems.push_back(myItems[index]); }
+
+   virtual size_t GetCustomHeight(int index) { return myItems[index].mExpanded ? 300 : 0; }
+
+   // my datas
+   MySequence() : mFrameMin(0), mFrameMax(0) {}
+   int mFrameMin, mFrameMax;
+   struct MySequenceItem
+   {
+      int mType;
+      int mFrameStart, mFrameEnd;
+      bool mExpanded;
+   };
+   std::vector<MySequenceItem> myItems;
+   RampEdit rampEdit;
+
+   virtual void DoubleClick(int index) {
+      if (myItems[index].mExpanded)
+      {
+         myItems[index].mExpanded = false;
+         return;
+      }
+      for (auto& item : myItems)
+         item.mExpanded = false;
+      myItems[index].mExpanded = !myItems[index].mExpanded;
+   }
+
+   virtual void CustomDraw(int index, ImDrawList* draw_list, const ImRect& rc, const ImRect& legendRect, const ImRect& clippingRect, const ImRect& legendClippingRect)
+   {
+      static const char* labels[] = { "Translation", "Rotation" , "Scale" };
+
+      rampEdit.mMax = ImVec2(float(mFrameMax), 1.f);
+      rampEdit.mMin = ImVec2(float(mFrameMin), 0.f);
+      draw_list->PushClipRect(legendClippingRect.Min, legendClippingRect.Max, true);
+      for (int i = 0; i < 3; i++)
+      {
+         ImVec2 pta(legendRect.Min.x + 30, legendRect.Min.y + i * 14.f);
+         ImVec2 ptb(legendRect.Max.x, legendRect.Min.y + (i + 1) * 14.f);
+         draw_list->AddText(pta, rampEdit.mbVisible[i] ? 0xFFFFFFFF : 0x80FFFFFF, labels[i]);
+         if (ImRect(pta, ptb).Contains(ImGui::GetMousePos()) && ImGui::IsMouseClicked(0))
+            rampEdit.mbVisible[i] = !rampEdit.mbVisible[i];
+      }
+      draw_list->PopClipRect();
+
+      ImGui::SetCursorScreenPos(rc.Min);
+      ImCurveEdit::Edit(rampEdit, rc.Max - rc.Min, 137 + index, &clippingRect);
+   }
+
+   virtual void CustomDrawCompact(int index, ImDrawList* draw_list, const ImRect& rc, const ImRect& clippingRect)
+   {
+      rampEdit.mMax = ImVec2(float(mFrameMax), 1.f);
+      rampEdit.mMin = ImVec2(float(mFrameMin), 0.f);
+      draw_list->PushClipRect(clippingRect.Min, clippingRect.Max, true);
+      for (int i = 0; i < 3; i++)
+      {
+         for (int j = 0; j < rampEdit.mPointCount[i]; j++)
+         {
+            float p = rampEdit.mPts[i][j].x;
+            if (p < myItems[index].mFrameStart || p > myItems[index].mFrameEnd)
+               continue;
+            float r = (p - mFrameMin) / float(mFrameMax - mFrameMin);
+            float x = ImLerp(rc.Min.x, rc.Max.x, r);
+            draw_list->AddLine(ImVec2(x, rc.Min.y + 6), ImVec2(x, rc.Max.y - 4), 0xAA000000, 4.f);
+         }
+      }
+      draw_list->PopClipRect();
+   }
+};
+
+//
+//
+// GraphEditor interface
+//
+//
+
+
+template <typename T, std::size_t N>
+struct Array
+{
+   T data[N];
+   const size_t size() const { return N; }
+
+   const T operator [] (size_t index) const { return data[index]; }
+   operator T* () {
+      T* p = new T[N];
+      memcpy(p, data, sizeof(data));
+      return p;
+   }
+};
+
+template <typename T, typename ... U> Array(T, U...)->Array<T, 1 + sizeof...(U)>;
+
+struct GraphEditorDelegate : public GraphEditor::Delegate
+{
+   bool AllowedLink(GraphEditor::NodeIndex from, GraphEditor::NodeIndex to) override
+   {
+      return true;
+   }
+
+   void SelectNode(GraphEditor::NodeIndex nodeIndex, bool selected) override
+   {
+      mNodes[nodeIndex].mSelected = selected;
+   }
+
+   void MoveSelectedNodes(const ImVec2 delta) override
+   {
+      for (auto& node : mNodes)
+      {
+         if (!node.mSelected)
+         {
+            continue;
+         }
+         node.x += delta.x;
+         node.y += delta.y;
+      }
+   }
+
+   virtual void RightClick(GraphEditor::NodeIndex nodeIndex, GraphEditor::SlotIndex slotIndexInput, GraphEditor::SlotIndex slotIndexOutput) override
+   {
+   }
+
+   void AddLink(GraphEditor::NodeIndex inputNodeIndex, GraphEditor::SlotIndex inputSlotIndex, GraphEditor::NodeIndex outputNodeIndex, GraphEditor::SlotIndex outputSlotIndex) override
+   {
+      mLinks.push_back({ inputNodeIndex, inputSlotIndex, outputNodeIndex, outputSlotIndex });
+   }
+
+   void DelLink(GraphEditor::LinkIndex linkIndex) override
+   {
+      mLinks.erase(mLinks.begin() + linkIndex);
+   }
+
+   void CustomDraw(ImDrawList* drawList, ImRect rectangle, GraphEditor::NodeIndex nodeIndex) override
+   {
+      drawList->AddLine(rectangle.Min, rectangle.Max, IM_COL32(0, 0, 0, 255));
+      drawList->AddText(rectangle.Min, IM_COL32(255, 128, 64, 255), "Draw");
+   }
+
+   const size_t GetTemplateCount() override
+   {
+      return sizeof(mTemplates) / sizeof(GraphEditor::Template);
+   }
+
+   const GraphEditor::Template GetTemplate(GraphEditor::TemplateIndex index) override
+   {
+      return mTemplates[index];
+   }
+
+   const size_t GetNodeCount() override
+   {
+      return mNodes.size();
+   }
+
+   const GraphEditor::Node GetNode(GraphEditor::NodeIndex index) override
+   {
+      const auto& myNode = mNodes[index];
+      return GraphEditor::Node
+      {
+          myNode.name,
+          myNode.templateIndex,
+          ImRect(ImVec2(myNode.x, myNode.y), ImVec2(myNode.x + 200, myNode.y + 200)),
+          myNode.mSelected
+      };
+   }
+
+   const size_t GetLinkCount() override
+   {
+      return mLinks.size();
+   }
+
+   const GraphEditor::Link GetLink(GraphEditor::LinkIndex index) override
+   {
+      return mLinks[index];
+   }
+
+   // Graph datas
+   static const inline GraphEditor::Template mTemplates[] = {
+       {
+           IM_COL32(160, 160, 180, 255),
+           IM_COL32(100, 100, 140, 255),
+           IM_COL32(110, 110, 150, 255),
+           1,
+           Array{"MyInput"},
+           nullptr,
+           2,
+           Array{"MyOutput0", "MyOuput1"},
+           nullptr
+       },
+
+       {
+           IM_COL32(180, 160, 160, 255),
+           IM_COL32(140, 100, 100, 255),
+           IM_COL32(150, 110, 110, 255),
+           3,
+           nullptr,
+           Array{ IM_COL32(200,100,100,255), IM_COL32(100,200,100,255), IM_COL32(100,100,200,255) },
+           1,
+           Array{"MyOutput0"},
+           Array{ IM_COL32(200,200,200,255)}
+       }
+   };
+
+   struct Node
+   {
+      const char* name;
+      GraphEditor::TemplateIndex templateIndex;
+      float x, y;
+      bool mSelected;
+   };
+
+   std::vector<Node> mNodes = {
+       {
+           "My Node 0",
+           0,
+           0, 0,
+           false
+       },
+
+       {
+           "My Node 1",
+           0,
+           400, 0,
+           false
+       },
+
+       {
+           "My Node 2",
+           1,
+           400, 400,
+           false
+       }
+   };
+
+   std::vector<GraphEditor::Link> mLinks = { {0, 0, 1, 0} };
+};
+
+
+int main(int, char**)
+{
+   ImApp::ImApp imApp;
+
+   ImApp::Config config;
+   config.mWidth = 1280;
+   config.mHeight = 720;
+   //config.mFullscreen = true;
+   imApp.Init(config);
+
+   int lastUsing = 0;
+
+   float cameraView[16] =
+   { 1.f, 0.f, 0.f, 0.f,
+     0.f, 1.f, 0.f, 0.f,
+     0.f, 0.f, 1.f, 0.f,
+     0.f, 0.f, 0.f, 1.f };
+
+   float cameraProjection[16];
+
+   // build a procedural texture. Copy/pasted and adapted from https://rosettacode.org/wiki/Plasma_effect#Graphics_version
+   unsigned int procTexture;
+   glGenTextures(1, &procTexture);
+   glBindTexture(GL_TEXTURE_2D, procTexture);
+   uint32_t* tempBitmap = new uint32_t[256 * 256];
+   int index = 0;
+   for (int y = 0; y < 256; y++)
+   {
+      for (int x = 0; x < 256; x++)
+      {
+         float dx = x + .5f;
+         float dy = y + .5f;
+         float dv = sinf(x * 0.02f) + sinf(0.03f * (x + y)) + sinf(sqrtf(0.4f * (dx * dx + dy * dy) + 1.f));
+
+         tempBitmap[index] = 0xFF000000 +
+         (int(255 * fabsf(sinf(dv * 3.141592f))) << 16) +
+         (int(255 * fabsf(sinf(dv * 3.141592f + 2 * 3.141592f / 3))) << 8) + 
+         (int(255 * fabs(sin(dv * 3.141592f + 4.f * 3.141592f / 3.f))));
+
+         index++;
+      }
+   }
+   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, tempBitmap);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+   delete [] tempBitmap;
+
+   // sequence with default values
+   MySequence mySequence;
+   mySequence.mFrameMin = -100;
+   mySequence.mFrameMax = 1000;
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 0, 10, 30, false });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 1, 20, 30, true });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 3, 12, 60, false });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 2, 61, 90, false });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 4, 90, 99, false });
+
+   // Camera projection
+   bool isPerspective = true;
+   float fov = 27.f;
+   float viewWidth = 10.f; // for orthographic
+   float camYAngle = 165.f / 180.f * 3.14159f;
+   float camXAngle = 32.f / 180.f * 3.14159f;
+
+   bool firstFrame = true;
+
+   // Main loop
+   while (!imApp.Done())
+   {
+      imApp.NewFrame();
+
+      ImGuiIO& io = ImGui::GetIO();
+      if (isPerspective)
+      {
+         Perspective(fov, io.DisplaySize.x / io.DisplaySize.y, 0.1f, 100.f, cameraProjection);
+      }
+      else
+      {
+         float viewHeight = viewWidth * io.DisplaySize.y / io.DisplaySize.x;
+         OrthoGraphic(-viewWidth, viewWidth, -viewHeight, viewHeight, 1000.f, -1000.f, cameraProjection);
+      }
+      ImGuizmo::SetOrthographic(!isPerspective);
+      ImGuizmo::BeginFrame();
+
+      ImGui::SetNextWindowPos(ImVec2(1024, 100));
+      ImGui::SetNextWindowSize(ImVec2(256, 256));
+
+      // create a window and insert the inspector
+      ImGui::SetNextWindowPos(ImVec2(10, 10));
+      ImGui::SetNextWindowSize(ImVec2(320, 340));
+      ImGui::Begin("Editor");
+      if (ImGui::RadioButton("Full view", !useWindow)) useWindow = false;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Window", useWindow)) useWindow = true;
+
+      ImGui::Text("Camera");
+      bool viewDirty = false;
+      if (ImGui::RadioButton("Perspective", isPerspective)) isPerspective = true;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Orthographic", !isPerspective)) isPerspective = false;
+      if (isPerspective)
+      {
+         ImGui::SliderFloat("Fov", &fov, 20.f, 110.f);
+      }
+      else
+      {
+         ImGui::SliderFloat("Ortho width", &viewWidth, 1, 20);
+      }
+      viewDirty |= ImGui::SliderFloat("Distance", &camDistance, 1.f, 10.f);
+      ImGui::SliderInt("Gizmo count", &gizmoCount, 1, 4);
+
+      if (viewDirty || firstFrame)
+      {
+         float eye[] = { cosf(camYAngle) * cosf(camXAngle) * camDistance, sinf(camXAngle) * camDistance, sinf(camYAngle) * cosf(camXAngle) * camDistance };
+         float at[] = { 0.f, 0.f, 0.f };
+         float up[] = { 0.f, 1.f, 0.f };
+         LookAt(eye, at, up, cameraView);
+         firstFrame = false;
+      }
+
+      ImGui::Text("X: %f Y: %f", io.MousePos.x, io.MousePos.y);
+      if (ImGuizmo::IsUsing())
+      {
+         ImGui::Text("Using gizmo");
+      }
+      else
+      {
+         ImGui::Text(ImGuizmo::IsOver()?"Over gizmo":"");
+         ImGui::SameLine();
+         ImGui::Text(ImGuizmo::IsOver(ImGuizmo::TRANSLATE) ? "Over translate gizmo" : "");
+         ImGui::SameLine();
+         ImGui::Text(ImGuizmo::IsOver(ImGuizmo::ROTATE) ? "Over rotate gizmo" : "");
+         ImGui::SameLine();
+         ImGui::Text(ImGuizmo::IsOver(ImGuizmo::SCALE) ? "Over scale gizmo" : "");
+      }
+      ImGui::Separator();
+      for (int matId = 0; matId < gizmoCount; matId++)
+      {
+         ImGuizmo::SetID(matId);
+
+         EditTransform(cameraView, cameraProjection, objectMatrix[matId], lastUsing == matId);
+         if (ImGuizmo::IsUsing())
+         {
+            lastUsing = matId;
+         }
+      }
+
+      ImGui::End();
+
+      ImGui::SetNextWindowPos(ImVec2(10, 350));
+
+      ImGui::SetNextWindowSize(ImVec2(940, 480));
+      ImGui::Begin("Other controls");
+      if (ImGui::CollapsingHeader("Zoom Slider"))
+      {
+         static float uMin = 0.4f, uMax = 0.6f;
+         static float vMin = 0.4f, vMax = 0.6f;
+         ImGui::Image((ImTextureID)(uint64_t)procTexture, ImVec2(900,300), ImVec2(uMin, vMin), ImVec2(uMax, vMax));
+         {
+            ImGui::SameLine();
+            ImGui::PushID(18);
+            ImZoomSlider::ImZoomSlider(0.f, 1.f, vMin, vMax, 0.01f, ImZoomSlider::ImGuiZoomSliderFlags_Vertical);
+            ImGui::PopID();
+         }
+      
+         {
+            ImGui::PushID(19);
+            ImZoomSlider::ImZoomSlider(0.f, 1.f, uMin, uMax);
+            ImGui::PopID();
+         }
+      }
+      if (ImGui::CollapsingHeader("Sequencer"))
+      {
+         // let's create the sequencer
+         static int selectedEntry = -1;
+         static int firstFrame = 0;
+         static bool expanded = true;
+         static int currentFrame = 100;
+
+         ImGui::PushItemWidth(130);
+         ImGui::InputInt("Frame Min", &mySequence.mFrameMin);
+         ImGui::SameLine();
+         ImGui::InputInt("Frame ", &currentFrame);
+         ImGui::SameLine();
+         ImGui::InputInt("Frame Max", &mySequence.mFrameMax);
+         ImGui::PopItemWidth();
+         Sequencer(&mySequence, &currentFrame, &expanded, &selectedEntry, &firstFrame, ImSequencer::SEQUENCER_EDIT_STARTEND | ImSequencer::SEQUENCER_ADD | ImSequencer::SEQUENCER_DEL | ImSequencer::SEQUENCER_COPYPASTE | ImSequencer::SEQUENCER_CHANGE_FRAME);
+         // add a UI to edit that particular item
+         if (selectedEntry != -1)
+         {
+           const MySequence::MySequenceItem &item = mySequence.myItems[selectedEntry];
+           ImGui::Text("I am a %s, please edit me", SequencerItemTypeNames[item.mType]);
+           // switch (type) ....
+         }
+      }
+
+      // Graph Editor
+      static GraphEditor::Options options;
+      static GraphEditorDelegate delegate;
+      static GraphEditor::ViewState viewState;
+      static GraphEditor::FitOnScreen fit = GraphEditor::Fit_None;
+      static bool showGraphEditor = true;
+
+      if (ImGui::CollapsingHeader("Graph Editor"))
+      {
+         ImGui::Checkbox("Show GraphEditor", &showGraphEditor);
+         GraphEditor::EditOptions(options);
+      }
+
+      ImGui::End();
+
+      if (showGraphEditor)
+      {
+         ImGui::Begin("Graph Editor", NULL, 0);
+         if (ImGui::Button("Fit all nodes"))
+         {
+            fit = GraphEditor::Fit_AllNodes;
+         }
+         ImGui::SameLine();
+         if (ImGui::Button("Fit selected nodes"))
+         {
+            fit = GraphEditor::Fit_SelectedNodes;
+         }
+         GraphEditor::Show(delegate, options, viewState, true, &fit);
+
+         ImGui::End();
+      }
+
+      // render everything
+      glClearColor(0.45f, 0.4f, 0.4f, 1.f);
+      glClear(GL_COLOR_BUFFER_BIT);
+      imApp.EndFrame();
+   }
+
+   imApp.Finish();
+
+   return 0;
+}

3rdparty/ImGuizmo/vcpkg-example/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(vcpkg-example)
+
+add_definitions(-DSTB_IMAGE_IMPLEMENTATION)
+find_path(STB_INCLUDE_DIRS "stb.h")
+
+find_package(imgui     CONFIG REQUIRED)
+find_package(imguizmo  CONFIG REQUIRED)
+
+add_executable(example-app)
+
+target_sources(example-app PRIVATE main.cpp)
+
+target_compile_options(example-app PRIVATE "/std:c++17")
+
+target_include_directories(example-app PRIVATE
+    ${STB_INCLUDE_DIRS}
+)
+
+target_link_libraries(example-app PRIVATE
+    imgui::imgui
+    imguizmo::imguizmo
+)

3rdparty/ImGuizmo/vcpkg-example/README.md

@@ -0,0 +1,52 @@
+# ImGuizmo example
+
+ImGuizmo example app that uses [cmake][cmake] and [vcpkg][vcpkg]
+
+## Setup
+
+Assuming cmake and vcpkg are installed, all that is required is to add the vcpkg toolchain file to
+the cmake configure and all dependencies will be downloaded and installed into the project
+
+```bash
+mkdir build
+cd build
+cmake .. -DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/scripts/buildsystem/vcpkg.cmake
+```
+
+### Visual Studio
+
+Rather than running directly, IDEs usually configure the cmake. Visual studio can be integrated
+directly with the `vcpkg integrate install` command or by specifying the path to the toolchain file
+in the project cmake settings
+
+### VSCode
+
+When using the cmake tools extension the command can be added to the `.vscode/settings.json` file as
+follows
+
+```json
+{
+    "cmake.configureArgs": [
+        "-DCMAKE_TOOLCHAIN_FILE=C:\\dev\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake"
+    ]
+}
+```
+
+> :heavy_check_mark: If you include the settings file in your repo, a good practice would be to use
+an environment variable for the path to the vcpkg install and variable substitution in the toolchain
+file path so the settings work across machines. eg `"-DCMAKE_TOOLCHAIN_FILE={$env:VCPKG_ROOT}\\scripts\\buildsystems\\vcpkg.cmake"`
+
+This can also be added to the system-wide settings rather than added to each project individually
+
+## How It Works
+
+The example contains a `vcpkg.json` manifest file that contains the dependencices. When cmake is
+supplied with the vcpkg toolchain file, the script detects this manifest file and then downloads and
+compiles the dependencies there-in
+
+In `CMakeLists.txt` the `find_package(imguizmo CONFIG REQUIRED)` command finds the cmake config
+added by the vcpkg install and `target_link_libraries(example-app PRIVATE imguizmo::imguizmo)` adds
+the includes and lib to the target
+
+[cmake]: https://cmake.org/
+[vcpkg]: https://github.com/microsoft/vcpkg

3rdparty/ImGuizmo/vcpkg-example/imgui.ini

@@ -0,0 +1,25 @@
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Window][Editor]
+Pos=10,10
+Size=320,340
+Collapsed=0
+
+[Window][Graph Editor]
+Pos=976,359
+Size=1325,844
+Collapsed=0
+
+[Window][Other controls]
+Pos=10,350
+Size=940,480
+Collapsed=0
+
+[Window][Gizmo]
+Pos=400,20
+Size=800,400
+Collapsed=0
+

3rdparty/ImGuizmo/vcpkg-example/main.cpp

@@ -0,0 +1,888 @@
+#include "imgui.h"
+#define IMGUI_DEFINE_MATH_OPERATORS
+#include "imgui_internal.h"
+#define IMAPP_IMPL
+#include "ImApp.h"
+
+#include "ImGuizmo.h"
+#include "ImSequencer.h"
+#include "ImZoomSlider.h"
+#include "ImCurveEdit.h"
+#include "GraphEditor.h"
+
+#include <math.h>
+#include <vector>
+#include <algorithm>
+
+bool useWindow = true;
+int gizmoCount = 1;
+float camDistance = 8.f;
+static ImGuizmo::OPERATION mCurrentGizmoOperation(ImGuizmo::TRANSLATE);
+
+float objectMatrix[4][16] = {
+  { 1.f, 0.f, 0.f, 0.f,
+    0.f, 1.f, 0.f, 0.f,
+    0.f, 0.f, 1.f, 0.f,
+    0.f, 0.f, 0.f, 1.f },
+
+  { 1.f, 0.f, 0.f, 0.f,
+  0.f, 1.f, 0.f, 0.f,
+  0.f, 0.f, 1.f, 0.f,
+  2.f, 0.f, 0.f, 1.f },
+
+  { 1.f, 0.f, 0.f, 0.f,
+  0.f, 1.f, 0.f, 0.f,
+  0.f, 0.f, 1.f, 0.f,
+  2.f, 0.f, 2.f, 1.f },
+
+  { 1.f, 0.f, 0.f, 0.f,
+  0.f, 1.f, 0.f, 0.f,
+  0.f, 0.f, 1.f, 0.f,
+  0.f, 0.f, 2.f, 1.f }
+};
+
+static const float identityMatrix[16] =
+{ 1.f, 0.f, 0.f, 0.f,
+    0.f, 1.f, 0.f, 0.f,
+    0.f, 0.f, 1.f, 0.f,
+    0.f, 0.f, 0.f, 1.f };
+
+void Frustum(float left, float right, float bottom, float top, float znear, float zfar, float* m16)
+{
+   float temp, temp2, temp3, temp4;
+   temp = 2.0f * znear;
+   temp2 = right - left;
+   temp3 = top - bottom;
+   temp4 = zfar - znear;
+   m16[0] = temp / temp2;
+   m16[1] = 0.0;
+   m16[2] = 0.0;
+   m16[3] = 0.0;
+   m16[4] = 0.0;
+   m16[5] = temp / temp3;
+   m16[6] = 0.0;
+   m16[7] = 0.0;
+   m16[8] = (right + left) / temp2;
+   m16[9] = (top + bottom) / temp3;
+   m16[10] = (-zfar - znear) / temp4;
+   m16[11] = -1.0f;
+   m16[12] = 0.0;
+   m16[13] = 0.0;
+   m16[14] = (-temp * zfar) / temp4;
+   m16[15] = 0.0;
+}
+
+void Perspective(float fovyInDegrees, float aspectRatio, float znear, float zfar, float* m16)
+{
+   float ymax, xmax;
+   ymax = znear * tanf(fovyInDegrees * 3.141592f / 180.0f);
+   xmax = ymax * aspectRatio;
+   Frustum(-xmax, xmax, -ymax, ymax, znear, zfar, m16);
+}
+
+void Cross(const float* a, const float* b, float* r)
+{
+   r[0] = a[1] * b[2] - a[2] * b[1];
+   r[1] = a[2] * b[0] - a[0] * b[2];
+   r[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+float Dot(const float* a, const float* b)
+{
+   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+void Normalize(const float* a, float* r)
+{
+   float il = 1.f / (sqrtf(Dot(a, a)) + FLT_EPSILON);
+   r[0] = a[0] * il;
+   r[1] = a[1] * il;
+   r[2] = a[2] * il;
+}
+
+void LookAt(const float* eye, const float* at, const float* up, float* m16)
+{
+   float X[3], Y[3], Z[3], tmp[3];
+
+   tmp[0] = eye[0] - at[0];
+   tmp[1] = eye[1] - at[1];
+   tmp[2] = eye[2] - at[2];
+   Normalize(tmp, Z);
+   Normalize(up, Y);
+
+   Cross(Y, Z, tmp);
+   Normalize(tmp, X);
+
+   Cross(Z, X, tmp);
+   Normalize(tmp, Y);
+
+   m16[0] = X[0];
+   m16[1] = Y[0];
+   m16[2] = Z[0];
+   m16[3] = 0.0f;
+   m16[4] = X[1];
+   m16[5] = Y[1];
+   m16[6] = Z[1];
+   m16[7] = 0.0f;
+   m16[8] = X[2];
+   m16[9] = Y[2];
+   m16[10] = Z[2];
+   m16[11] = 0.0f;
+   m16[12] = -Dot(X, eye);
+   m16[13] = -Dot(Y, eye);
+   m16[14] = -Dot(Z, eye);
+   m16[15] = 1.0f;
+}
+
+void OrthoGraphic(const float l, float r, float b, const float t, float zn, const float zf, float* m16)
+{
+   m16[0] = 2 / (r - l);
+   m16[1] = 0.0f;
+   m16[2] = 0.0f;
+   m16[3] = 0.0f;
+   m16[4] = 0.0f;
+   m16[5] = 2 / (t - b);
+   m16[6] = 0.0f;
+   m16[7] = 0.0f;
+   m16[8] = 0.0f;
+   m16[9] = 0.0f;
+   m16[10] = 1.0f / (zf - zn);
+   m16[11] = 0.0f;
+   m16[12] = (l + r) / (l - r);
+   m16[13] = (t + b) / (b - t);
+   m16[14] = zn / (zn - zf);
+   m16[15] = 1.0f;
+}
+
+inline void rotationY(const float angle, float* m16)
+{
+   float c = cosf(angle);
+   float s = sinf(angle);
+
+   m16[0] = c;
+   m16[1] = 0.0f;
+   m16[2] = -s;
+   m16[3] = 0.0f;
+   m16[4] = 0.0f;
+   m16[5] = 1.f;
+   m16[6] = 0.0f;
+   m16[7] = 0.0f;
+   m16[8] = s;
+   m16[9] = 0.0f;
+   m16[10] = c;
+   m16[11] = 0.0f;
+   m16[12] = 0.f;
+   m16[13] = 0.f;
+   m16[14] = 0.f;
+   m16[15] = 1.0f;
+}
+
+void EditTransform(float* cameraView, float* cameraProjection, float* matrix, bool editTransformDecomposition)
+{
+   static ImGuizmo::MODE mCurrentGizmoMode(ImGuizmo::LOCAL);
+   static bool useSnap = false;
+   static float snap[3] = { 1.f, 1.f, 1.f };
+   static float bounds[] = { -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, 0.5f };
+   static float boundsSnap[] = { 0.1f, 0.1f, 0.1f };
+   static bool boundSizing = false;
+   static bool boundSizingSnap = false;
+
+   if (editTransformDecomposition)
+   {
+      if (ImGui::IsKeyPressed(90))
+         mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+      if (ImGui::IsKeyPressed(69))
+         mCurrentGizmoOperation = ImGuizmo::ROTATE;
+      if (ImGui::IsKeyPressed(82)) // r Key
+         mCurrentGizmoOperation = ImGuizmo::SCALE;
+      if (ImGui::RadioButton("Translate", mCurrentGizmoOperation == ImGuizmo::TRANSLATE))
+         mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE))
+         mCurrentGizmoOperation = ImGuizmo::ROTATE;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Scale", mCurrentGizmoOperation == ImGuizmo::SCALE))
+         mCurrentGizmoOperation = ImGuizmo::SCALE;
+      float matrixTranslation[3], matrixRotation[3], matrixScale[3];
+      ImGuizmo::DecomposeMatrixToComponents(matrix, matrixTranslation, matrixRotation, matrixScale);
+      ImGui::InputFloat3("Tr", matrixTranslation);
+      ImGui::InputFloat3("Rt", matrixRotation);
+      ImGui::InputFloat3("Sc", matrixScale);
+      ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, matrix);
+
+      if (mCurrentGizmoOperation != ImGuizmo::SCALE)
+      {
+         if (ImGui::RadioButton("Local", mCurrentGizmoMode == ImGuizmo::LOCAL))
+            mCurrentGizmoMode = ImGuizmo::LOCAL;
+         ImGui::SameLine();
+         if (ImGui::RadioButton("World", mCurrentGizmoMode == ImGuizmo::WORLD))
+            mCurrentGizmoMode = ImGuizmo::WORLD;
+      }
+      if (ImGui::IsKeyPressed(83))
+         useSnap = !useSnap;
+      ImGui::Checkbox("", &useSnap);
+      ImGui::SameLine();
+
+      switch (mCurrentGizmoOperation)
+      {
+      case ImGuizmo::TRANSLATE:
+         ImGui::InputFloat3("Snap", &snap[0]);
+         break;
+      case ImGuizmo::ROTATE:
+         ImGui::InputFloat("Angle Snap", &snap[0]);
+         break;
+      case ImGuizmo::SCALE:
+         ImGui::InputFloat("Scale Snap", &snap[0]);
+         break;
+      }
+      ImGui::Checkbox("Bound Sizing", &boundSizing);
+      if (boundSizing)
+      {
+         ImGui::PushID(3);
+         ImGui::Checkbox("", &boundSizingSnap);
+         ImGui::SameLine();
+         ImGui::InputFloat3("Snap", boundsSnap);
+         ImGui::PopID();
+      }
+   }
+
+   ImGuiIO& io = ImGui::GetIO();
+   float viewManipulateRight = io.DisplaySize.x;
+   float viewManipulateTop = 0;
+   if (useWindow)
+   {
+      ImGui::SetNextWindowSize(ImVec2(800, 400));
+      ImGui::SetNextWindowPos(ImVec2(400,20));
+      ImGui::PushStyleColor(ImGuiCol_WindowBg, (ImVec4)ImColor(0.35f, 0.3f, 0.3f));
+      ImGui::Begin("Gizmo", 0, ImGuiWindowFlags_NoMove);
+      ImGuizmo::SetDrawlist();
+      float windowWidth = (float)ImGui::GetWindowWidth();
+      float windowHeight = (float)ImGui::GetWindowHeight();
+      ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, windowWidth, windowHeight);
+      viewManipulateRight = ImGui::GetWindowPos().x + windowWidth;
+      viewManipulateTop = ImGui::GetWindowPos().y;
+   }
+   else
+   {
+      ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);
+   }
+
+   ImGuizmo::DrawGrid(cameraView, cameraProjection, identityMatrix, 100.f);
+   ImGuizmo::DrawCubes(cameraView, cameraProjection, &objectMatrix[0][0], gizmoCount);
+   ImGuizmo::Manipulate(cameraView, cameraProjection, mCurrentGizmoOperation, mCurrentGizmoMode, matrix, NULL, useSnap ? &snap[0] : NULL, boundSizing ? bounds : NULL, boundSizingSnap ? boundsSnap : NULL);
+
+   ImGuizmo::ViewManipulate(cameraView, camDistance, ImVec2(viewManipulateRight - 128, viewManipulateTop), ImVec2(128, 128), 0x10101010);
+
+   if (useWindow)
+   {
+      ImGui::End();
+      ImGui::PopStyleColor(1);
+   }
+}
+
+//
+//
+// ImSequencer interface
+//
+//
+static const char* SequencerItemTypeNames[] = { "Camera","Music", "ScreenEffect", "FadeIn", "Animation" };
+
+struct RampEdit : public ImCurveEdit::Delegate
+{
+   RampEdit()
+   {
+      mPts[0][0] = ImVec2(-10.f, 0);
+      mPts[0][1] = ImVec2(20.f, 0.6f);
+      mPts[0][2] = ImVec2(25.f, 0.2f);
+      mPts[0][3] = ImVec2(70.f, 0.4f);
+      mPts[0][4] = ImVec2(120.f, 1.f);
+      mPointCount[0] = 5;
+
+      mPts[1][0] = ImVec2(-50.f, 0.2f);
+      mPts[1][1] = ImVec2(33.f, 0.7f);
+      mPts[1][2] = ImVec2(80.f, 0.2f);
+      mPts[1][3] = ImVec2(82.f, 0.8f);
+      mPointCount[1] = 4;
+
+
+      mPts[2][0] = ImVec2(40.f, 0);
+      mPts[2][1] = ImVec2(60.f, 0.1f);
+      mPts[2][2] = ImVec2(90.f, 0.82f);
+      mPts[2][3] = ImVec2(150.f, 0.24f);
+      mPts[2][4] = ImVec2(200.f, 0.34f);
+      mPts[2][5] = ImVec2(250.f, 0.12f);
+      mPointCount[2] = 6;
+      mbVisible[0] = mbVisible[1] = mbVisible[2] = true;
+      mMax = ImVec2(1.f, 1.f);
+      mMin = ImVec2(0.f, 0.f);
+   }
+   size_t GetCurveCount()
+   {
+      return 3;
+   }
+
+   bool IsVisible(size_t curveIndex)
+   {
+      return mbVisible[curveIndex];
+   }
+   size_t GetPointCount(size_t curveIndex)
+   {
+      return mPointCount[curveIndex];
+   }
+
+   uint32_t GetCurveColor(size_t curveIndex)
+   {
+      uint32_t cols[] = { 0xFF0000FF, 0xFF00FF00, 0xFFFF0000 };
+      return cols[curveIndex];
+   }
+   ImVec2* GetPoints(size_t curveIndex)
+   {
+      return mPts[curveIndex];
+   }
+   virtual ImCurveEdit::CurveType GetCurveType(size_t curveIndex) const { return ImCurveEdit::CurveSmooth; }
+   virtual int EditPoint(size_t curveIndex, int pointIndex, ImVec2 value)
+   {
+      mPts[curveIndex][pointIndex] = ImVec2(value.x, value.y);
+      SortValues(curveIndex);
+      for (size_t i = 0; i < GetPointCount(curveIndex); i++)
+      {
+         if (mPts[curveIndex][i].x == value.x)
+            return (int)i;
+      }
+      return pointIndex;
+   }
+   virtual void AddPoint(size_t curveIndex, ImVec2 value)
+   {
+      if (mPointCount[curveIndex] >= 8)
+         return;
+      mPts[curveIndex][mPointCount[curveIndex]++] = value;
+      SortValues(curveIndex);
+   }
+   virtual ImVec2& GetMax() { return mMax; }
+   virtual ImVec2& GetMin() { return mMin; }
+   virtual unsigned int GetBackgroundColor() { return 0; }
+   ImVec2 mPts[3][8];
+   size_t mPointCount[3];
+   bool mbVisible[3];
+   ImVec2 mMin;
+   ImVec2 mMax;
+private:
+   void SortValues(size_t curveIndex)
+   {
+      auto b = std::begin(mPts[curveIndex]);
+      auto e = std::begin(mPts[curveIndex]) + GetPointCount(curveIndex);
+      std::sort(b, e, [](ImVec2 a, ImVec2 b) { return a.x < b.x; });
+
+   }
+};
+
+struct MySequence : public ImSequencer::SequenceInterface
+{
+   // interface with sequencer
+
+   virtual int GetFrameMin() const {
+      return mFrameMin;
+   }
+   virtual int GetFrameMax() const {
+      return mFrameMax;
+   }
+   virtual int GetItemCount() const { return (int)myItems.size(); }
+
+   virtual int GetItemTypeCount() const { return sizeof(SequencerItemTypeNames) / sizeof(char*); }
+   virtual const char* GetItemTypeName(int typeIndex) const { return SequencerItemTypeNames[typeIndex]; }
+   virtual const char* GetItemLabel(int index) const
+   {
+      static char tmps[512];
+      snprintf(tmps, 512, "[%02d] %s", index, SequencerItemTypeNames[myItems[index].mType]);
+      return tmps;
+   }
+
+   virtual void Get(int index, int** start, int** end, int* type, unsigned int* color)
+   {
+      MySequenceItem& item = myItems[index];
+      if (color)
+         *color = 0xFFAA8080; // same color for everyone, return color based on type
+      if (start)
+         *start = &item.mFrameStart;
+      if (end)
+         *end = &item.mFrameEnd;
+      if (type)
+         *type = item.mType;
+   }
+   virtual void Add(int type) { myItems.push_back(MySequenceItem{ type, 0, 10, false }); };
+   virtual void Del(int index) { myItems.erase(myItems.begin() + index); }
+   virtual void Duplicate(int index) { myItems.push_back(myItems[index]); }
+
+   virtual size_t GetCustomHeight(int index) { return myItems[index].mExpanded ? 300 : 0; }
+
+   // my datas
+   MySequence() : mFrameMin(0), mFrameMax(0) {}
+   int mFrameMin, mFrameMax;
+   struct MySequenceItem
+   {
+      int mType;
+      int mFrameStart, mFrameEnd;
+      bool mExpanded;
+   };
+   std::vector<MySequenceItem> myItems;
+   RampEdit rampEdit;
+
+   virtual void DoubleClick(int index) {
+      if (myItems[index].mExpanded)
+      {
+         myItems[index].mExpanded = false;
+         return;
+      }
+      for (auto& item : myItems)
+         item.mExpanded = false;
+      myItems[index].mExpanded = !myItems[index].mExpanded;
+   }
+
+   virtual void CustomDraw(int index, ImDrawList* draw_list, const ImRect& rc, const ImRect& legendRect, const ImRect& clippingRect, const ImRect& legendClippingRect)
+   {
+      static const char* labels[] = { "Translation", "Rotation" , "Scale" };
+
+      rampEdit.mMax = ImVec2(float(mFrameMax), 1.f);
+      rampEdit.mMin = ImVec2(float(mFrameMin), 0.f);
+      draw_list->PushClipRect(legendClippingRect.Min, legendClippingRect.Max, true);
+      for (int i = 0; i < 3; i++)
+      {
+         ImVec2 pta(legendRect.Min.x + 30, legendRect.Min.y + i * 14.f);
+         ImVec2 ptb(legendRect.Max.x, legendRect.Min.y + (i + 1) * 14.f);
+         draw_list->AddText(pta, rampEdit.mbVisible[i] ? 0xFFFFFFFF : 0x80FFFFFF, labels[i]);
+         if (ImRect(pta, ptb).Contains(ImGui::GetMousePos()) && ImGui::IsMouseClicked(0))
+            rampEdit.mbVisible[i] = !rampEdit.mbVisible[i];
+      }
+      draw_list->PopClipRect();
+
+      ImGui::SetCursorScreenPos(rc.Min);
+      ImCurveEdit::Edit(rampEdit, rc.Max - rc.Min, 137 + index, &clippingRect);
+   }
+
+   virtual void CustomDrawCompact(int index, ImDrawList* draw_list, const ImRect& rc, const ImRect& clippingRect)
+   {
+      rampEdit.mMax = ImVec2(float(mFrameMax), 1.f);
+      rampEdit.mMin = ImVec2(float(mFrameMin), 0.f);
+      draw_list->PushClipRect(clippingRect.Min, clippingRect.Max, true);
+      for (int i = 0; i < 3; i++)
+      {
+         for (int j = 0; j < rampEdit.mPointCount[i]; j++)
+         {
+            float p = rampEdit.mPts[i][j].x;
+            if (p < myItems[index].mFrameStart || p > myItems[index].mFrameEnd)
+               continue;
+            float r = (p - mFrameMin) / float(mFrameMax - mFrameMin);
+            float x = ImLerp(rc.Min.x, rc.Max.x, r);
+            draw_list->AddLine(ImVec2(x, rc.Min.y + 6), ImVec2(x, rc.Max.y - 4), 0xAA000000, 4.f);
+         }
+      }
+      draw_list->PopClipRect();
+   }
+};
+
+//
+//
+// GraphEditor interface
+//
+//
+
+
+template <typename T, std::size_t N>
+struct Array
+{
+   T data[N];
+   const size_t size() const { return N; }
+
+   const T operator [] (size_t index) const { return data[index]; }
+   operator T* () {
+      T* p = new T[N];
+      memcpy(p, data, sizeof(data));
+      return p;
+   }
+};
+
+template <typename T, typename ... U>
+Array(T, U...) -> Array<T, 1 + sizeof...(U)>;
+
+struct GraphEditorDelegate : public GraphEditor::Delegate
+{
+   bool AllowedLink(GraphEditor::NodeIndex from, GraphEditor::NodeIndex to) override
+   {
+      return true;
+   }
+
+   void SelectNode(GraphEditor::NodeIndex nodeIndex, bool selected) override
+   {
+      mNodes[nodeIndex].mSelected = selected;
+   }
+
+   void MoveSelectedNodes(const ImVec2 delta) override
+   {
+      for (auto& node : mNodes)
+      {
+         if (!node.mSelected)
+         {
+            continue;
+         }
+         node.x += delta.x;
+         node.y += delta.y;
+      }
+   }
+
+   virtual void RightClick(GraphEditor::NodeIndex nodeIndex, GraphEditor::SlotIndex slotIndexInput, GraphEditor::SlotIndex slotIndexOutput) override
+   {
+   }
+
+   void AddLink(GraphEditor::NodeIndex inputNodeIndex, GraphEditor::SlotIndex inputSlotIndex, GraphEditor::NodeIndex outputNodeIndex, GraphEditor::SlotIndex outputSlotIndex) override
+   {
+      mLinks.push_back({ inputNodeIndex, inputSlotIndex, outputNodeIndex, outputSlotIndex });
+   }
+
+   void DelLink(GraphEditor::LinkIndex linkIndex) override
+   {
+      mLinks.erase(mLinks.begin() + linkIndex);
+   }
+
+   void CustomDraw(ImDrawList* drawList, ImRect rectangle, GraphEditor::NodeIndex nodeIndex) override
+   {
+      drawList->AddLine(rectangle.Min, rectangle.Max, IM_COL32(0, 0, 0, 255));
+      drawList->AddText(rectangle.Min, IM_COL32(255, 128, 64, 255), "Draw");
+   }
+
+   const size_t GetTemplateCount() override
+   {
+      return sizeof(mTemplates) / sizeof(GraphEditor::Template);
+   }
+
+   const GraphEditor::Template GetTemplate(GraphEditor::TemplateIndex index) override
+   {
+      return mTemplates[index];
+   }
+
+   const size_t GetNodeCount() override
+   {
+      return mNodes.size();
+   }
+
+   const GraphEditor::Node GetNode(GraphEditor::NodeIndex index) override
+   {
+      const auto& myNode = mNodes[index];
+      return GraphEditor::Node
+      {
+          myNode.name,
+          myNode.templateIndex,
+          ImRect(ImVec2(myNode.x, myNode.y), ImVec2(myNode.x + 200, myNode.y + 200)),
+          myNode.mSelected
+      };
+   }
+
+   const size_t GetLinkCount() override
+   {
+      return mLinks.size();
+   }
+
+   const GraphEditor::Link GetLink(GraphEditor::LinkIndex index) override
+   {
+      return mLinks[index];
+   }
+
+   // Graph datas
+   static const inline GraphEditor::Template mTemplates[] = {
+       {
+           IM_COL32(160, 160, 180, 255),
+           IM_COL32(100, 100, 140, 255),
+           IM_COL32(110, 110, 150, 255),
+           1,
+           Array{"MyInput"},
+           nullptr,
+           2,
+           Array{"MyOutput0", "MyOuput1"},
+           nullptr
+       },
+
+       {
+           IM_COL32(180, 160, 160, 255),
+           IM_COL32(140, 100, 100, 255),
+           IM_COL32(150, 110, 110, 255),
+           3,
+           nullptr,
+           Array{ IM_COL32(200,100,100,255), IM_COL32(100,200,100,255), IM_COL32(100,100,200,255) },
+           1,
+           Array{"MyOutput0"},
+           Array{ IM_COL32(200,200,200,255)}
+       }
+   };
+
+   struct Node
+   {
+      const char* name;
+      GraphEditor::TemplateIndex templateIndex;
+      float x, y;
+      bool mSelected;
+   };
+
+   std::vector<Node> mNodes = {
+       {
+           "My Node 0",
+           0,
+           0, 0,
+           false
+       },
+
+       {
+           "My Node 1",
+           0,
+           400, 0,
+           false
+       },
+
+       {
+           "My Node 2",
+           1,
+           400, 400,
+           false
+       }
+   };
+
+   std::vector<GraphEditor::Link> mLinks = { {0, 0, 1, 0} };
+};
+
+
+int main(int, char**)
+{
+   ImApp::ImApp imApp;
+
+   ImApp::Config config;
+   config.mWidth = 1280;
+   config.mHeight = 720;
+   //config.mFullscreen = true;
+   imApp.Init(config);
+
+   int lastUsing = 0;
+
+   float cameraView[16] =
+   { 1.f, 0.f, 0.f, 0.f,
+     0.f, 1.f, 0.f, 0.f,
+     0.f, 0.f, 1.f, 0.f,
+     0.f, 0.f, 0.f, 1.f };
+
+   float cameraProjection[16];
+
+   // build a procedural texture. Copy/pasted and adapted from https://rosettacode.org/wiki/Plasma_effect#Graphics_version
+   unsigned int procTexture;
+   glGenTextures(1, &procTexture);
+   glBindTexture(GL_TEXTURE_2D, procTexture);
+   uint32_t* tempBitmap = new uint32_t[256 * 256];
+   int index = 0;
+   for (int y = 0; y < 256; y++)
+   {
+      for (int x = 0; x < 256; x++)
+      {
+         float dx = x + .5f;
+         float dy = y + .5f;
+         float dv = sinf(x * 0.02f) + sinf(0.03f * (x + y)) + sinf(sqrtf(0.4f * (dx * dx + dy * dy) + 1.f));
+
+         tempBitmap[index] = 0xFF000000 +
+         (int(255 * fabsf(sinf(dv * 3.141592f))) << 16) +
+         (int(255 * fabsf(sinf(dv * 3.141592f + 2 * 3.141592f / 3))) << 8) +
+         (int(255 * fabs(sin(dv * 3.141592f + 4.f * 3.141592f / 3.f))));
+
+         index++;
+      }
+   }
+   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, tempBitmap);
+   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+   delete [] tempBitmap;
+
+   // sequence with default values
+   MySequence mySequence;
+   mySequence.mFrameMin = -100;
+   mySequence.mFrameMax = 1000;
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 0, 10, 30, false });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 1, 20, 30, true });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 3, 12, 60, false });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 2, 61, 90, false });
+   mySequence.myItems.push_back(MySequence::MySequenceItem{ 4, 90, 99, false });
+
+   // Camera projection
+   bool isPerspective = true;
+   float fov = 27.f;
+   float viewWidth = 10.f; // for orthographic
+   float camYAngle = 165.f / 180.f * 3.14159f;
+   float camXAngle = 32.f / 180.f * 3.14159f;
+
+   bool firstFrame = true;
+
+   // Main loop
+   while (!imApp.Done())
+   {
+      imApp.NewFrame();
+
+      ImGuiIO& io = ImGui::GetIO();
+      if (isPerspective)
+      {
+         Perspective(fov, io.DisplaySize.x / io.DisplaySize.y, 0.1f, 100.f, cameraProjection);
+      }
+      else
+      {
+         float viewHeight = viewWidth * io.DisplaySize.y / io.DisplaySize.x;
+         OrthoGraphic(-viewWidth, viewWidth, -viewHeight, viewHeight, 1000.f, -1000.f, cameraProjection);
+      }
+      ImGuizmo::SetOrthographic(!isPerspective);
+      ImGuizmo::BeginFrame();
+
+      ImGui::SetNextWindowPos(ImVec2(1024, 100));
+      ImGui::SetNextWindowSize(ImVec2(256, 256));
+
+      // create a window and insert the inspector
+      ImGui::SetNextWindowPos(ImVec2(10, 10));
+      ImGui::SetNextWindowSize(ImVec2(320, 340));
+      ImGui::Begin("Editor");
+      if (ImGui::RadioButton("Full view", !useWindow)) useWindow = false;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Window", useWindow)) useWindow = true;
+
+      ImGui::Text("Camera");
+      bool viewDirty = false;
+      if (ImGui::RadioButton("Perspective", isPerspective)) isPerspective = true;
+      ImGui::SameLine();
+      if (ImGui::RadioButton("Orthographic", !isPerspective)) isPerspective = false;
+      if (isPerspective)
+      {
+         ImGui::SliderFloat("Fov", &fov, 20.f, 110.f);
+      }
+      else
+      {
+         ImGui::SliderFloat("Ortho width", &viewWidth, 1, 20);
+      }
+      viewDirty |= ImGui::SliderFloat("Distance", &camDistance, 1.f, 10.f);
+      ImGui::SliderInt("Gizmo count", &gizmoCount, 1, 4);
+
+      if (viewDirty || firstFrame)
+      {
+         float eye[] = { cosf(camYAngle) * cosf(camXAngle) * camDistance, sinf(camXAngle) * camDistance, sinf(camYAngle) * cosf(camXAngle) * camDistance };
+         float at[] = { 0.f, 0.f, 0.f };
+         float up[] = { 0.f, 1.f, 0.f };
+         LookAt(eye, at, up, cameraView);
+         firstFrame = false;
+      }
+
+      ImGui::Text("X: %f Y: %f", io.MousePos.x, io.MousePos.y);
+      if (ImGuizmo::IsUsing())
+      {
+         ImGui::Text("Using gizmo");
+      }
+      else
+      {
+         ImGui::Text(ImGuizmo::IsOver()?"Over gizmo":"");
+         ImGui::SameLine();
+         ImGui::Text(ImGuizmo::IsOver(ImGuizmo::TRANSLATE) ? "Over translate gizmo" : "");
+         ImGui::SameLine();
+         ImGui::Text(ImGuizmo::IsOver(ImGuizmo::ROTATE) ? "Over rotate gizmo" : "");
+         ImGui::SameLine();
+         ImGui::Text(ImGuizmo::IsOver(ImGuizmo::SCALE) ? "Over scale gizmo" : "");
+      }
+      ImGui::Separator();
+      for (int matId = 0; matId < gizmoCount; matId++)
+      {
+         ImGuizmo::SetID(matId);
+
+         EditTransform(cameraView, cameraProjection, objectMatrix[matId], lastUsing == matId);
+         if (ImGuizmo::IsUsing())
+         {
+            lastUsing = matId;
+         }
+      }
+
+      ImGui::End();
+
+      ImGui::SetNextWindowPos(ImVec2(10, 350));
+
+      ImGui::SetNextWindowSize(ImVec2(940, 480));
+      ImGui::Begin("Other controls");
+      if (ImGui::CollapsingHeader("Zoom Slider"))
+      {
+         static float uMin = 0.4f, uMax = 0.6f;
+         static float vMin = 0.4f, vMax = 0.6f;
+         ImGui::Image((ImTextureID)(uint64_t)procTexture, ImVec2(900,300), ImVec2(uMin, vMin), ImVec2(uMax, vMax));
+         {
+            ImGui::SameLine();
+            ImGui::PushID(18);
+            ImZoomSlider::ImZoomSlider(0.f, 1.f, vMin, vMax, 0.01f, ImZoomSlider::ImGuiZoomSliderFlags_Vertical);
+            ImGui::PopID();
+         }
+
+         {
+            ImGui::PushID(19);
+            ImZoomSlider::ImZoomSlider(0.f, 1.f, uMin, uMax);
+            ImGui::PopID();
+         }
+      }
+      if (ImGui::CollapsingHeader("Sequencer"))
+      {
+         // let's create the sequencer
+         static int selectedEntry = -1;
+         static int firstFrame = 0;
+         static bool expanded = true;
+         static int currentFrame = 100;
+
+         ImGui::PushItemWidth(130);
+         ImGui::InputInt("Frame Min", &mySequence.mFrameMin);
+         ImGui::SameLine();
+         ImGui::InputInt("Frame ", &currentFrame);
+         ImGui::SameLine();
+         ImGui::InputInt("Frame Max", &mySequence.mFrameMax);
+         ImGui::PopItemWidth();
+         Sequencer(&mySequence, &currentFrame, &expanded, &selectedEntry, &firstFrame, ImSequencer::SEQUENCER_EDIT_STARTEND | ImSequencer::SEQUENCER_ADD | ImSequencer::SEQUENCER_DEL | ImSequencer::SEQUENCER_COPYPASTE | ImSequencer::SEQUENCER_CHANGE_FRAME);
+         // add a UI to edit that particular item
+         if (selectedEntry != -1)
+         {
+           const MySequence::MySequenceItem &item = mySequence.myItems[selectedEntry];
+           ImGui::Text("I am a %s, please edit me", SequencerItemTypeNames[item.mType]);
+           // switch (type) ....
+         }
+      }
+
+      // Graph Editor
+      static GraphEditor::Options options;
+      static GraphEditorDelegate delegate;
+      static GraphEditor::ViewState viewState;
+      static GraphEditor::FitOnScreen fit = GraphEditor::Fit_None;
+      static bool showGraphEditor = true;
+
+      if (ImGui::CollapsingHeader("Graph Editor"))
+      {
+         ImGui::Checkbox("Show GraphEditor", &showGraphEditor);
+         GraphEditor::EditOptions(options);
+      }
+
+      ImGui::End();
+
+      if (showGraphEditor)
+      {
+         ImGui::Begin("Graph Editor", NULL, 0);
+         if (ImGui::Button("Fit all nodes"))
+         {
+            fit = GraphEditor::Fit_AllNodes;
+         }
+         ImGui::SameLine();
+         if (ImGui::Button("Fit selected nodes"))
+         {
+            fit = GraphEditor::Fit_SelectedNodes;
+         }
+         GraphEditor::Show(delegate, options, viewState, true, &fit);
+
+         ImGui::End();
+      }
+
+
+      // render everything
+      glClearColor(0.45f, 0.4f, 0.4f, 1.f);
+      glClear(GL_COLOR_BUFFER_BIT);
+      imApp.EndFrame();
+   }
+
+   imApp.Finish();
+
+   return 0;
+}

3rdparty/ImGuizmo/vcpkg-example/vcpkg.json

@@ -0,0 +1,9 @@
+{
+    "name": "vcpkg-example",
+    "version": "1.83",
+    "dependencies": [
+        "imgui",
+        "imguizmo",
+        "stb"
+    ]
+}

3rdparty/tracy/capture/build/unix/Makefile

@@ -0,0 +1,12 @@
+all: release
+
+debug:
+	@+make -f debug.mk all
+
+release:
+	@+make -f release.mk all
+
+clean:
+	@+make -f build.mk clean
+
+.PHONY: all clean debug release

3rdparty/tracy/capture/build/unix/build.mk

@@ -0,0 +1,12 @@
+CFLAGS +=
+CXXFLAGS := $(CFLAGS) -std=gnu++17
+DEFINES += -DTRACY_NO_STATISTICS
+INCLUDES := $(shell pkg-config --cflags capstone)
+LIBS += $(shell pkg-config --libs capstone) -lpthread
+PROJECT := capture
+IMAGE := $(PROJECT)-$(BUILD)
+
+FILTER := ../../../getopt/getopt.c
+include ../../../common/src-from-vcxproj.mk
+
+include ../../../common/unix.mk

3rdparty/tracy/capture/build/unix/debug.mk

@@ -0,0 +1,11 @@
+ARCH := $(shell uname -m)
+
+CFLAGS := -g3 -Wall
+DEFINES := -DDEBUG
+BUILD := debug
+
+ifeq ($(ARCH),x86_64)
+CFLAGS += -msse4.1
+endif
+
+include build.mk

3rdparty/tracy/capture/build/unix/release.mk

@@ -0,0 +1,6 @@
+CFLAGS := -O3 -flto
+DEFINES := -DNDEBUG
+BUILD := release
+
+include ../../../common/unix-release.mk
+include build.mk

3rdparty/tracy/capture/build/win32/capture.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30907.101
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "capture", "capture.vcxproj", "{447D58BF-94CD-4469-BB90-549C05D03E00}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.ActiveCfg = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.Build.0 = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.ActiveCfg = Release|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3E51386C-43EA-44AC-9F24-AFAFE4D63ADE}
+	EndGlobalSection
+EndGlobal

3rdparty/tracy/capture/build/win32/capture.vcxproj

@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{447D58BF-94CD-4469-BB90-549C05D03E00}</ProjectGuid>
+    <RootNamespace>capture</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <VcpkgTriplet>x64-windows-static</VcpkgTriplet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>TRACY_NO_STATISTICS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\debug\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>TRACY_NO_STATISTICS;NDEBUG;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp" />
+    <ClCompile Include="..\..\..\common\TracySystem.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp" />
+    <ClCompile Include="..\..\..\getopt\getopt.c" />
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp" />
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp" />
+    <ClCompile Include="..\..\..\server\TracyStackFrames.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp" />
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp" />
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp" />
+    <ClCompile Include="..\..\..\zstd\common\debug.c" />
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c" />
+    <ClCompile Include="..\..\..\zstd\common\error_private.c" />
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\common\pool.c" />
+    <ClCompile Include="..\..\..\zstd\common\threading.c" />
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c" />
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c" />
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\hist.c" />
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c" />
+    <ClCompile Include="..\..\src\capture.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp" />
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp" />
+    <ClInclude Include="..\..\..\common\TracyColor.hpp" />
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp" />
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp" />
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp" />
+    <ClInclude Include="..\..\..\common\TracySocket.hpp" />
+    <ClInclude Include="..\..\..\common\TracySystem.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp" />
+    <ClInclude Include="..\..\..\getopt\getopt.h" />
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp" />
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp" />
+    <ClInclude Include="..\..\..\server\TracySlab.hpp" />
+    <ClInclude Include="..\..\..\server\TracyStackFrames.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp" />
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVector.hpp" />
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp" />
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h" />
+    <ClInclude Include="..\..\..\zstd\common\compiler.h" />
+    <ClInclude Include="..\..\..\zstd\common\cpu.h" />
+    <ClInclude Include="..\..\..\zstd\common\debug.h" />
+    <ClInclude Include="..\..\..\zstd\common\error_private.h" />
+    <ClInclude Include="..\..\..\zstd\common\fse.h" />
+    <ClInclude Include="..\..\..\zstd\common\huf.h" />
+    <ClInclude Include="..\..\..\zstd\common\mem.h" />
+    <ClInclude Include="..\..\..\zstd\common\pool.h" />
+    <ClInclude Include="..\..\..\zstd\common\threading.h" />
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h" />
+    <ClInclude Include="..\..\..\zstd\compress\hist.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h" />
+    <ClInclude Include="..\..\..\zstd\zdict.h" />
+    <ClInclude Include="..\..\..\zstd\zstd.h" />
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/tracy/capture/build/win32/capture.vcxproj.filters

@@ -0,0 +1,348 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="src">
+      <UniqueIdentifier>{729c80ee-4d26-4a5e-8f1f-6c075783eb56}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="server">
+      <UniqueIdentifier>{cf23ef7b-7694-4154-830b-00cf053350ea}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="common">
+      <UniqueIdentifier>{e39d3623-47cd-4752-8da9-3ea324f964c1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="getopt">
+      <UniqueIdentifier>{ee9737d2-69c7-44da-b9c7-539d18f9d4b4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd">
+      <UniqueIdentifier>{f201463b-5e69-46fe-bdfc-1b5eed86c7f7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\common">
+      <UniqueIdentifier>{7e93ae33-6543-4bca-b05b-50818dbf24cc}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\compress">
+      <UniqueIdentifier>{3b0c32f5-9efb-4503-9394-5ab95909fb1c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\decompress">
+      <UniqueIdentifier>{c1f99170-d904-4af1-8010-0a3ded5736c8}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\dictBuilder">
+      <UniqueIdentifier>{456e6786-ea57-42b8-ae38-829cd2d918bd}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySystem.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\capture.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\getopt\getopt.c">
+      <Filter>getopt</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyStackFrames.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\debug.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\error_private.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\pool.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\threading.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\hist.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyColor.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySocket.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySystem.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySlab.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVector.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\getopt\getopt.h">
+      <Filter>getopt</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyStackFrames.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\compiler.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\cpu.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\debug.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\error_private.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\fse.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\huf.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\mem.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\pool.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\threading.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\hist.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zdict.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

3rdparty/tracy/csvexport/build/unix/Makefile

@@ -0,0 +1,12 @@
+all: release
+
+debug:
+	@+make -f debug.mk all
+
+release:
+	@+make -f release.mk all
+
+clean:
+	@+make -f build.mk clean
+
+.PHONY: all clean debug release

3rdparty/tracy/csvexport/build/unix/build.mk

@@ -0,0 +1,12 @@
+CFLAGS +=
+CXXFLAGS := $(CFLAGS) -std=gnu++17
+# DEFINES += -DTRACY_NO_STATISTICS
+INCLUDES := $(shell pkg-config --cflags capstone)
+LIBS := $(shell pkg-config --libs capstone) -lpthread
+PROJECT := csvexport
+IMAGE := $(PROJECT)-$(BUILD)
+
+FILTER :=
+include ../../../common/src-from-vcxproj.mk
+
+include ../../../common/unix.mk

3rdparty/tracy/csvexport/build/unix/debug.mk

@@ -0,0 +1,11 @@
+ARCH := $(shell uname -m)
+
+CFLAGS := -g3 -Wall
+DEFINES := -DDEBUG
+BUILD := debug
+
+ifeq ($(ARCH),x86_64)
+CFLAGS += -msse4.1
+endif
+
+include build.mk

3rdparty/tracy/csvexport/build/unix/release.mk

@@ -0,0 +1,6 @@
+CFLAGS := -O3 -flto
+DEFINES := -DNDEBUG
+BUILD := release
+
+include ../../../common/unix-release.mk
+include build.mk

3rdparty/tracy/csvexport/build/win32/csvexport.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30907.101
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "csvexport", "csvexport.vcxproj", "{447D58BF-94CD-4469-BB90-549C05D03E00}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.ActiveCfg = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.Build.0 = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.ActiveCfg = Release|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3E51386C-43EA-44AC-9F24-AFAFE4D63ADE}
+	EndGlobalSection
+EndGlobal

3rdparty/tracy/csvexport/build/win32/csvexport.vcxproj

@@ -0,0 +1,196 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{447D58BF-94CD-4469-BB90-549C05D03E00}</ProjectGuid>
+    <RootNamespace>capture</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <VcpkgTriplet>x64-windows-static</VcpkgTriplet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\debug\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>NDEBUG;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp" />
+    <ClCompile Include="..\..\..\common\TracySystem.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp" />
+    <ClCompile Include="..\..\..\getopt\getopt.c" />
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp" />
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp" />
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp" />
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp" />
+    <ClCompile Include="..\..\..\zstd\common\debug.c" />
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c" />
+    <ClCompile Include="..\..\..\zstd\common\error_private.c" />
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\common\pool.c" />
+    <ClCompile Include="..\..\..\zstd\common\threading.c" />
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c" />
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c" />
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\hist.c" />
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c" />
+    <ClCompile Include="..\..\src\csvexport.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp" />
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp" />
+    <ClInclude Include="..\..\..\common\TracyColor.hpp" />
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp" />
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp" />
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp" />
+    <ClInclude Include="..\..\..\common\TracySocket.hpp" />
+    <ClInclude Include="..\..\..\common\TracySystem.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp" />
+    <ClInclude Include="..\..\..\getopt\getopt.h" />
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp" />
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp" />
+    <ClInclude Include="..\..\..\server\TracySlab.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp" />
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVector.hpp" />
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp" />
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h" />
+    <ClInclude Include="..\..\..\zstd\common\compiler.h" />
+    <ClInclude Include="..\..\..\zstd\common\cpu.h" />
+    <ClInclude Include="..\..\..\zstd\common\debug.h" />
+    <ClInclude Include="..\..\..\zstd\common\error_private.h" />
+    <ClInclude Include="..\..\..\zstd\common\fse.h" />
+    <ClInclude Include="..\..\..\zstd\common\huf.h" />
+    <ClInclude Include="..\..\..\zstd\common\mem.h" />
+    <ClInclude Include="..\..\..\zstd\common\pool.h" />
+    <ClInclude Include="..\..\..\zstd\common\threading.h" />
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h" />
+    <ClInclude Include="..\..\..\zstd\compress\hist.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h" />
+    <ClInclude Include="..\..\..\zstd\zdict.h" />
+    <ClInclude Include="..\..\..\zstd\zstd.h" />
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/tracy/csvexport/build/win32/csvexport.vcxproj.filters

@@ -0,0 +1,342 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="src">
+      <UniqueIdentifier>{729c80ee-4d26-4a5e-8f1f-6c075783eb56}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="server">
+      <UniqueIdentifier>{cf23ef7b-7694-4154-830b-00cf053350ea}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="common">
+      <UniqueIdentifier>{e39d3623-47cd-4752-8da9-3ea324f964c1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="getopt">
+      <UniqueIdentifier>{ee9737d2-69c7-44da-b9c7-539d18f9d4b4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd">
+      <UniqueIdentifier>{44ea1742-0fd9-40ba-879c-031868509600}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\common">
+      <UniqueIdentifier>{2d065bba-d78e-4e44-87f7-b44cf3248260}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\compress">
+      <UniqueIdentifier>{a19ca3bc-2a17-49c5-a0d9-5916213de774}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\decompress">
+      <UniqueIdentifier>{d4181058-2198-4931-ae31-b7eda0312458}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\dictBuilder">
+      <UniqueIdentifier>{873c22fe-b4d7-480d-ad67-48271296f4c1}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySystem.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\getopt\getopt.c">
+      <Filter>getopt</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\csvexport.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\debug.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\error_private.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\pool.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\threading.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\hist.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyColor.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySocket.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySystem.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySlab.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVector.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\getopt\getopt.h">
+      <Filter>getopt</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\compiler.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\cpu.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\debug.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\error_private.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\fse.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\huf.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\mem.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\pool.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\threading.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\hist.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zdict.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

3rdparty/tracy/extra/systrace/build.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+# These may be passed as environment variables, or will use the following defaults.
+: ${CC:=clang}
+: ${STRIP:=strip}
+: ${SSTRIP:=sstrip}
+
+if [ ! -x "$(command -v "${CC}")" ]
+then
+  echo "Set the CC environment variable to a C compiler."
+  exit 1
+fi
+
+if [ ! -x "$(command -v "${STRIP}")" ]
+then
+  echo "Set the STRIP environment variable to the strip utility."
+  exit 1
+fi
+
+if [ ! -x "$(command -v "${SSTRIP}")" ]
+then
+  echo "Set the SSTRIP environment variable to the sstrip utility, which can be obtained from https://github.com/BR903/ELFkickers ."
+  exit 1
+fi
+
+$CC tracy_systrace.c -s -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -fno-stack-protector -Wl,-z,norelro -Wl,--build-id=none -nostdlib -ldl -o tracy_systrace
+
+$STRIP --strip-all -R .note.gnu.gold-version -R .comment -R .note -R .note.gnu.build-id -R .note.ABI-tag -R .eh_frame -R .eh_frame_hdr -R .gnu.version -R .got tracy_systrace
+
+$SSTRIP -z tracy_systrace
+

3rdparty/tracy/import-chrome/build/unix/Makefile

@@ -0,0 +1,12 @@
+all: release
+
+debug:
+	@+make -f debug.mk all
+
+release:
+	@+make -f release.mk all
+
+clean:
+	@+make -f build.mk clean
+
+.PHONY: all clean debug release

3rdparty/tracy/import-chrome/build/unix/build.mk

@@ -0,0 +1,12 @@
+CFLAGS +=
+CXXFLAGS := $(CFLAGS) -std=gnu++17
+DEFINES += -DTRACY_NO_STATISTICS
+INCLUDES := $(shell pkg-config --cflags capstone)
+LIBS += $(shell pkg-config --libs capstone) -lpthread
+PROJECT := import-chrome
+IMAGE := $(PROJECT)-$(BUILD)
+
+FILTER :=
+include ../../../common/src-from-vcxproj.mk
+
+include ../../../common/unix.mk

3rdparty/tracy/import-chrome/build/unix/debug.mk

@@ -0,0 +1,11 @@
+ARCH := $(shell uname -m)
+
+CFLAGS := -g3 -Wall
+DEFINES := -DDEBUG
+BUILD := debug
+
+ifeq ($(ARCH),x86_64)
+CFLAGS += -msse4.1
+endif
+
+include build.mk

3rdparty/tracy/import-chrome/build/unix/release.mk

@@ -0,0 +1,6 @@
+CFLAGS := -O3 -flto
+DEFINES := -DNDEBUG
+BUILD := release
+
+include ../../../common/unix-release.mk
+include build.mk

3rdparty/tracy/import-chrome/build/win32/import-chrome.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30907.101
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "import-chrome", "import-chrome.vcxproj", "{447D58BF-94CD-4469-BB90-549C05D03E00}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.ActiveCfg = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.Build.0 = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.ActiveCfg = Release|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3E51386C-43EA-44AC-9F24-AFAFE4D63ADE}
+	EndGlobalSection
+EndGlobal

3rdparty/tracy/import-chrome/build/win32/import-chrome.vcxproj

@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{447D58BF-94CD-4469-BB90-549C05D03E00}</ProjectGuid>
+    <RootNamespace>import-chrome</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <VcpkgTriplet>x64-windows-static</VcpkgTriplet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>TRACY_NO_STATISTICS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\debug\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>TRACY_NO_STATISTICS;NDEBUG;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp" />
+    <ClCompile Include="..\..\..\common\TracySystem.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp" />
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp" />
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp" />
+    <ClCompile Include="..\..\..\zstd\common\debug.c" />
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c" />
+    <ClCompile Include="..\..\..\zstd\common\error_private.c" />
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\common\pool.c" />
+    <ClCompile Include="..\..\..\zstd\common\threading.c" />
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c" />
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c" />
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\hist.c" />
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c" />
+    <ClCompile Include="..\..\src\import-chrome.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp" />
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp" />
+    <ClInclude Include="..\..\..\common\TracyColor.hpp" />
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp" />
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp" />
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp" />
+    <ClInclude Include="..\..\..\common\TracySocket.hpp" />
+    <ClInclude Include="..\..\..\common\TracySystem.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp" />
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp" />
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp" />
+    <ClInclude Include="..\..\..\server\TracySlab.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp" />
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVector.hpp" />
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp" />
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h" />
+    <ClInclude Include="..\..\..\zstd\common\compiler.h" />
+    <ClInclude Include="..\..\..\zstd\common\cpu.h" />
+    <ClInclude Include="..\..\..\zstd\common\debug.h" />
+    <ClInclude Include="..\..\..\zstd\common\error_private.h" />
+    <ClInclude Include="..\..\..\zstd\common\fse.h" />
+    <ClInclude Include="..\..\..\zstd\common\huf.h" />
+    <ClInclude Include="..\..\..\zstd\common\mem.h" />
+    <ClInclude Include="..\..\..\zstd\common\pool.h" />
+    <ClInclude Include="..\..\..\zstd\common\threading.h" />
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h" />
+    <ClInclude Include="..\..\..\zstd\compress\hist.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h" />
+    <ClInclude Include="..\..\..\zstd\zdict.h" />
+    <ClInclude Include="..\..\..\zstd\zstd.h" />
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/tracy/import-chrome/build/win32/import-chrome.vcxproj.filters

@@ -0,0 +1,327 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="src">
+      <UniqueIdentifier>{729c80ee-4d26-4a5e-8f1f-6c075783eb56}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="server">
+      <UniqueIdentifier>{cf23ef7b-7694-4154-830b-00cf053350ea}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="common">
+      <UniqueIdentifier>{e39d3623-47cd-4752-8da9-3ea324f964c1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd">
+      <UniqueIdentifier>{9ec18988-3ab7-4c05-a9d0-46c0a68037de}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\common">
+      <UniqueIdentifier>{5ee9ba63-2914-4027-997e-e743a294bba6}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\compress">
+      <UniqueIdentifier>{a166d032-7be0-4d07-9f85-a8199cc1ec7c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\decompress">
+      <UniqueIdentifier>{438fff23-197c-4b6f-91f0-74f8b3878571}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\dictBuilder">
+      <UniqueIdentifier>{e5c7021a-e0e4-45c2-b461-e806bc036d5f}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySystem.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\import-chrome.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\debug.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\error_private.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\pool.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\threading.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\hist.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyColor.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySocket.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySystem.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySlab.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVector.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\compiler.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\cpu.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\debug.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\error_private.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\fse.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\huf.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\mem.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\pool.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\threading.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\hist.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zdict.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

3rdparty/tracy/library/unix/build.mk

@@ -0,0 +1,12 @@
+CFLAGS +=
+CXXFLAGS := $(CFLAGS) -std=gnu++17 -fpic
+DEFINES += -DTRACY_ENABLE
+INCLUDES :=
+LIBS := -lpthread -ldl
+PROJECT := libtracy
+IMAGE := $(PROJECT)-$(BUILD).so
+SHARED_LIBRARY := yes
+
+SRC := ../../TracyClient.cpp
+
+include ../../common/unix.mk

3rdparty/tracy/profiler/build/unix/Makefile

@@ -0,0 +1,12 @@
+all: release
+
+debug:
+	@+make -f debug.mk all
+
+release:
+	@+make -f release.mk all
+
+clean:
+	@+make -f build.mk clean
+
+.PHONY: all clean debug release

3rdparty/tracy/profiler/build/unix/build.mk

@@ -0,0 +1,36 @@
+CFLAGS +=
+CXXFLAGS := $(CFLAGS) -std=c++17
+DEFINES += -DIMGUI_IMPL_OPENGL_LOADER_GL3W -DIMGUI_ENABLE_FREETYPE
+INCLUDES := $(shell pkg-config --cflags glfw3 freetype2 capstone) -I../../../imgui -I../../libs/gl3w
+LIBS := $(shell pkg-config --libs glfw3 freetype2 capstone) -lpthread -ldl
+
+DISPLAY_SERVER := X11
+
+ifdef TRACY_USE_WAYLAND
+	DISPLAY_SERVER := WAYLAND
+	LIBS += $(shell pkg-config --libs wayland-client)
+endif
+
+CXXFLAGS += -D"DISPLAY_SERVER_$(DISPLAY_SERVER)"
+
+PROJECT := Tracy
+IMAGE := $(PROJECT)-$(BUILD)
+
+FILTER := ../../../nfd/nfd_win.cpp
+include ../../../common/src-from-vcxproj.mk
+
+ifdef TRACY_NO_FILESELECTOR
+	CXXFLAGS += -DTRACY_NO_FILESELECTOR
+else
+	UNAME := $(shell uname -s)
+	ifeq ($(UNAME),Darwin)
+		SRC3 += ../../../nfd/nfd_cocoa.m
+		LIBS +=  -framework CoreFoundation -framework AppKit
+	else
+		SRC2 += ../../../nfd/nfd_gtk.c
+		INCLUDES += $(shell pkg-config --cflags gtk+-3.0)
+		LIBS += $(shell pkg-config --libs gtk+-3.0)
+	endif
+endif
+
+include ../../../common/unix.mk

3rdparty/tracy/profiler/build/unix/debug.mk

@@ -0,0 +1,11 @@
+ARCH := $(shell uname -m)
+
+CFLAGS := -g3 -Wall
+DEFINES := -DDEBUG
+BUILD := debug
+
+ifeq ($(ARCH),x86_64)
+CFLAGS += -msse4.1
+endif
+
+include build.mk

3rdparty/tracy/profiler/build/unix/release.mk

@@ -0,0 +1,6 @@
+CFLAGS := -O3 -flto
+DEFINES := -DNDEBUG
+BUILD := release
+
+include ../../../common/unix-release.mk
+include build.mk

3rdparty/tracy/profiler/build/win32/DebugVis.natvis

@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+  <Type Name="tracy::Vector&lt;*&gt;">
+    <DisplayString>{{ size={m_size} }}</DisplayString>
+    <Expand>
+      <Item Name="[capacity]" ExcludeView="simple">m_capacity == 255 ? m_size : m_ptr == nullptr ? 0 : 1 &lt;&lt; m_capacity</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <Type Name="tracy::VarArray&lt;*&gt;">
+    <DisplayString>{{ size={m_size} hash={m_hash} }}</DisplayString>
+    <Expand>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <Type Name="tracy::FastVector&lt;*&gt;">
+    <DisplayString>{{ size={m_write - m_ptr} }}</DisplayString>
+    <Expand>
+      <Item Name="[capacity]" ExcludeView="simple">m_end - m_ptr</Item>
+      <ArrayItems>
+        <Size>m_write - m_ptr</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <Type Name="tracy::ContextSwitchData">
+    <DisplayString>{{ start={int64_t( _start_cpu ) >> 16} end={int64_t( _end_reason_state ) >> 16} cpu={uint8_t( _start_cpu &amp; 0xFF )} reason={int8_t( (_end_reason_state >> 8) &amp; 0xFF )} state={int8_t( _end_reason_state &amp; 0xFF )} }}</DisplayString>
+  </Type>
+  <Type Name="tracy::ContextSwitchCpu">
+    <DisplayString>{{ start={int64_t( _start_thread ) >> 16} end={_end} thread={uint16_t( _start_thread )} }}</DisplayString>
+  </Type>
+  <Type Name="tracy::ContextSwitchUsage">
+    <DisplayString>{{ time={int64_t( _time_other_own ) >> 16} own={uint8_t( _time_other_own >> 8 )} other={uint8_t( _time_other_own )} }}</DisplayString>
+  </Type>
+  <Type Name="tracy::Int24">
+    <DisplayString>{{ value={m_val[0] | (m_val[1]&lt;&lt;8) | (m_val[2]&lt;&lt;16)} }}</DisplayString>
+  </Type>
+  <Type Name="tracy::Int48">
+    <DisplayString>{{ value={int64_t( uint64_t(m_val[0]) | (uint64_t(m_val[1])&lt;&lt;8) | (uint64_t(m_val[2])&lt;&lt;16) | (uint64_t(m_val[3])&lt;&lt;24) | (uint64_t(m_val[4])&lt;&lt;32) | (uint64_t(m_val[5])&lt;&lt;40) )} }}</DisplayString>
+  </Type>
+  <Type Name="tracy::detail::Table&lt;*,*,*,*,*,*&gt;">
+    <!--
+  $T1 = bool IsFlat
+  $T2 = size_t MaxLoadFactor100
+  $T3 = typename Key
+  $T4 = typename T
+  $T5 = typename Hash
+  $T6 = typename KeyEqual
+-->
+    <!-- <DisplayString>{map}</DisplayString> -->
+    <Expand>
+      <Synthetic Name="[elements]">
+        <DisplayString>{{size={mNumElements}}}</DisplayString>
+        <Expand>
+          <CustomListItems MaxItemsPerView="5000" >
+            <Variable Name="itKeyVals"    InitialValue="mKeyVals     " />
+            <Variable Name="itInfo"       InitialValue="mInfo        " />
+            <Variable Name="itEndKeyVals" InitialValue="(void *)mInfo " />
+            <Variable Name="n"            InitialValue="0ULL         " />
+            <Variable Name="inc"          InitialValue="(unsigned long)0" />
+
+            <Size>mNumElements</Size>
+            <Loop>
+              <!-- Fast forward -->
+              <Exec>n = *((size_t*)itInfo)</Exec>
+              <Loop>
+                <Break Condition="n != 0" />
+                <Exec>itInfo += sizeof(size_t)</Exec>
+                <Exec>itKeyVals += sizeof(size_t)</Exec>
+              </Loop>
+              <!-- Count Trailing Zeros -->
+              <Exec>
+                inc = n == 0
+                ? 64
+                : (
+                63
+                - (((n &amp; (~n + 1)) &amp; 0x00000000FFFFFFFF) ? 32 : 0)
+                - (((n &amp; (~n + 1)) &amp; 0x0000FFFF0000FFFF) ? 16 : 0)
+                - (((n &amp; (~n + 1)) &amp; 0x00FF00FF00FF00FF) ? 8  : 0)
+                - (((n &amp; (~n + 1)) &amp; 0x0F0F0F0F0F0F0F0F) ? 4  : 0)
+                - (((n &amp; (~n + 1)) &amp; 0x3333333333333333) ? 2  : 0)
+                - (((n &amp; (~n + 1)) &amp; 0x5555555555555555) ? 1  : 0)
+                )
+              </Exec>
+              <Exec>itInfo    += inc / 8</Exec>
+              <Exec>itKeyVals += inc / 8</Exec>
+              <!-- Fast forward -->
+              <Break Condition="(void*)itKeyVals == itEndKeyVals" />
+              <Item Name="[{itKeyVals-&gt;mData.first}]">itKeyVals-&gt;mData.second</Item>
+              <!-- <Item>itKeyVals-&gt;mData</Item> -->
+              <Exec>itInfo++   </Exec>
+              <Exec>itKeyVals++</Exec>
+            </Loop>
+          </CustomListItems>
+        </Expand>
+      </Synthetic>
+      <Item Name="[load_factor]"    >float(mNumElements) / float(mMask + 1)</Item>
+      <Item Name="[max_load_factor]">$T2</Item>
+      <Item Name="[IsFlat]"         >$T1</Item>
+      <Item Name="[hash_function]"  >*(WrapHash&lt;$T5&gt;*)this,nd</Item>
+      <Item Name="[key_eq]"         >*(WrapKeyEqual&lt;$T6&gt;*)this,nd</Item>
+    </Expand>
+  </Type>
+</AutoVisualizer>

3rdparty/tracy/profiler/build/win32/Tracy.manifest

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <application>
+    <windowsSettings>
+      <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
+    </windowsSettings>
+  </application>
+</assembly>

3rdparty/tracy/profiler/build/win32/Tracy.rc

@@ -0,0 +1 @@
+IDI_ICON1               ICON                    "../../../icon/icon.ico"

3rdparty/tracy/profiler/build/win32/Tracy.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30907.101
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Tracy", "Tracy.vcxproj", "{1C736F84-08DF-4A7A-A7FB-7BA3412B8C97}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1C736F84-08DF-4A7A-A7FB-7BA3412B8C97}.Debug|x64.ActiveCfg = Debug|x64
+		{1C736F84-08DF-4A7A-A7FB-7BA3412B8C97}.Debug|x64.Build.0 = Debug|x64
+		{1C736F84-08DF-4A7A-A7FB-7BA3412B8C97}.Release|x64.ActiveCfg = Release|x64
+		{1C736F84-08DF-4A7A-A7FB-7BA3412B8C97}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {B342B16A-09E1-4039-A153-6C1D28857536}
+	EndGlobalSection
+EndGlobal

3rdparty/tracy/profiler/build/win32/Tracy.vcxproj

@@ -0,0 +1,301 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{1C736F84-08DF-4A7A-A7FB-7BA3412B8C97}</ProjectGuid>
+    <RootNamespace>Tracy</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <VcpkgTriplet>x64-windows-static</VcpkgTriplet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Linkage-freetype>static</Linkage-freetype>
+    <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Linkage-freetype>static</Linkage-freetype>
+    <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;IMGUI_ENABLE_FREETYPE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\..\libs\gl3w;..\..\..\imgui;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <MinimalRebuild>false</MinimalRebuild>
+      <ConformanceMode>true</ConformanceMode>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <DiagnosticsFormat>Caret</DiagnosticsFormat>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <FloatingPointModel>Fast</FloatingPointModel>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>brotlicommon-static.lib;brotlidec-static.lib;ws2_32.lib;freetyped.lib;glfw3.lib;libpng16d.lib;zlibd.lib;bz2d.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\debug\lib</AdditionalLibraryDirectories>
+    </Link>
+    <Manifest>
+      <EnableDpiAwareness>true</EnableDpiAwareness>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;IMGUI_ENABLE_FREETYPE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\..\libs\gl3w;..\..\..\imgui;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <ConformanceMode>true</ConformanceMode>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <DiagnosticsFormat>Caret</DiagnosticsFormat>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <FloatingPointModel>Fast</FloatingPointModel>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>brotlicommon-static.lib;brotlidec-static.lib;ws2_32.lib;freetype.lib;glfw3.lib;libpng16.lib;zlib.lib;bz2.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\lib</AdditionalLibraryDirectories>
+    </Link>
+    <Manifest>
+      <EnableDpiAwareness>true</EnableDpiAwareness>
+    </Manifest>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp" />
+    <ClCompile Include="..\..\..\common\TracySystem.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp" />
+    <ClCompile Include="..\..\..\imgui\imgui.cpp" />
+    <ClCompile Include="..\..\..\imgui\imgui_demo.cpp" />
+    <ClCompile Include="..\..\..\imgui\imgui_draw.cpp" />
+    <ClCompile Include="..\..\..\imgui\imgui_tables.cpp" />
+    <ClCompile Include="..\..\..\imgui\imgui_widgets.cpp" />
+    <ClCompile Include="..\..\..\imgui\misc\freetype\imgui_freetype.cpp" />
+    <ClCompile Include="..\..\..\nfd\nfd_common.c" />
+    <ClCompile Include="..\..\..\nfd\nfd_win.cpp" />
+    <ClCompile Include="..\..\..\server\TracyBadVersion.cpp" />
+    <ClCompile Include="..\..\..\server\TracyColor.cpp" />
+    <ClCompile Include="..\..\..\server\TracyFilesystem.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMicroArchitecture.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMouse.cpp" />
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp" />
+    <ClCompile Include="..\..\..\server\TracySourceContents.cpp" />
+    <ClCompile Include="..\..\..\server\TracySourceTokenizer.cpp" />
+    <ClCompile Include="..\..\..\server\TracySourceView.cpp" />
+    <ClCompile Include="..\..\..\server\TracyStackFrames.cpp" />
+    <ClCompile Include="..\..\..\server\TracyStorage.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTexture.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp" />
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp" />
+    <ClCompile Include="..\..\..\server\TracyUserData.cpp" />
+    <ClCompile Include="..\..\..\server\TracyView.cpp" />
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp" />
+    <ClCompile Include="..\..\..\zstd\common\debug.c" />
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c" />
+    <ClCompile Include="..\..\..\zstd\common\error_private.c" />
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\common\pool.c" />
+    <ClCompile Include="..\..\..\zstd\common\threading.c" />
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c" />
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c" />
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\hist.c" />
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c" />
+    <ClCompile Include="..\..\libs\gl3w\GL\gl3w.c" />
+    <ClCompile Include="..\..\src\HttpRequest.cpp" />
+    <ClCompile Include="..\..\src\imgui_impl_glfw.cpp" />
+    <ClCompile Include="..\..\src\imgui_impl_opengl3.cpp" />
+    <ClCompile Include="..\..\src\main.cpp" />
+    <ClCompile Include="..\..\src\NativeWindow.cpp" />
+    <ClCompile Include="..\..\src\ResolvService.cpp" />
+    <ClCompile Include="..\..\src\winmain.cpp">
+      <EnableEnhancedInstructionSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotSet</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotSet</EnableEnhancedInstructionSet>
+    </ClCompile>
+    <ClCompile Include="..\..\src\winmainArchDiscovery.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp" />
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp" />
+    <ClInclude Include="..\..\..\common\TracyMutex.hpp" />
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp" />
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp" />
+    <ClInclude Include="..\..\..\common\TracySocket.hpp" />
+    <ClInclude Include="..\..\..\common\TracySystem.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp" />
+    <ClInclude Include="..\..\..\imgui\imconfig.h" />
+    <ClInclude Include="..\..\..\imgui\imgui.h" />
+    <ClInclude Include="..\..\..\imgui\imgui_internal.h" />
+    <ClInclude Include="..\..\..\imgui\imstb_rectpack.h" />
+    <ClInclude Include="..\..\..\imgui\imstb_textedit.h" />
+    <ClInclude Include="..\..\..\imgui\imstb_truetype.h" />
+    <ClInclude Include="..\..\..\imgui\misc\freetype\imgui_freetype.h" />
+    <ClInclude Include="..\..\..\nfd\common.h" />
+    <ClInclude Include="..\..\..\nfd\nfd.h" />
+    <ClInclude Include="..\..\..\nfd\nfd_common.h" />
+    <ClInclude Include="..\..\..\server\IconsFontAwesome5.h" />
+    <ClInclude Include="..\..\..\server\TracyBadVersion.hpp" />
+    <ClInclude Include="..\..\..\server\TracyBuzzAnim.hpp" />
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp" />
+    <ClInclude Include="..\..\..\server\TracyColor.hpp" />
+    <ClInclude Include="..\..\..\server\TracyDecayValue.hpp" />
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileHeader.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFilesystem.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp" />
+    <ClInclude Include="..\..\..\server\TracyImGui.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMicroArchitecture.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMouse.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp" />
+    <ClInclude Include="..\..\..\server\TracyShortPtr.hpp" />
+    <ClInclude Include="..\..\..\server\TracySlab.hpp" />
+    <ClInclude Include="..\..\..\server\TracySort.hpp" />
+    <ClInclude Include="..\..\..\server\TracySortedVector.hpp" />
+    <ClInclude Include="..\..\..\server\TracySourceContents.hpp" />
+    <ClInclude Include="..\..\..\server\TracySourceTokenizer.hpp" />
+    <ClInclude Include="..\..\..\server\TracySourceView.hpp" />
+    <ClInclude Include="..\..\..\server\TracyStackFrames.hpp" />
+    <ClInclude Include="..\..\..\server\TracyStorage.hpp" />
+    <ClInclude Include="..\..\..\server\TracyStringDiscovery.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTexture.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp" />
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp" />
+    <ClInclude Include="..\..\..\server\TracyUserData.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVarArray.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVector.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVersion.hpp" />
+    <ClInclude Include="..\..\..\server\TracyView.hpp" />
+    <ClInclude Include="..\..\..\server\TracyViewData.hpp" />
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp" />
+    <ClInclude Include="..\..\..\server\TracyYield.hpp" />
+    <ClInclude Include="..\..\..\server\tracy_pdqsort.h" />
+    <ClInclude Include="..\..\..\server\tracy_robin_hood.h" />
+    <ClInclude Include="..\..\..\server\tracy_xxh3.h" />
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h" />
+    <ClInclude Include="..\..\..\zstd\common\compiler.h" />
+    <ClInclude Include="..\..\..\zstd\common\cpu.h" />
+    <ClInclude Include="..\..\..\zstd\common\debug.h" />
+    <ClInclude Include="..\..\..\zstd\common\error_private.h" />
+    <ClInclude Include="..\..\..\zstd\common\fse.h" />
+    <ClInclude Include="..\..\..\zstd\common\huf.h" />
+    <ClInclude Include="..\..\..\zstd\common\mem.h" />
+    <ClInclude Include="..\..\..\zstd\common\pool.h" />
+    <ClInclude Include="..\..\..\zstd\common\threading.h" />
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h" />
+    <ClInclude Include="..\..\..\zstd\compress\hist.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h" />
+    <ClInclude Include="..\..\..\zstd\zdict.h" />
+    <ClInclude Include="..\..\..\zstd\zstd.h" />
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h" />
+    <ClInclude Include="..\..\libs\gl3w\GL\gl3w.h" />
+    <ClInclude Include="..\..\libs\gl3w\GL\glcorearb.h" />
+    <ClInclude Include="..\..\src\Arimo.hpp" />
+    <ClInclude Include="..\..\src\Cousine.hpp" />
+    <ClInclude Include="..\..\src\FontAwesomeSolid.hpp" />
+    <ClInclude Include="..\..\src\HttpRequest.hpp" />
+    <ClInclude Include="..\..\src\icon.hpp" />
+    <ClInclude Include="..\..\src\imgui_impl_glfw.h" />
+    <ClInclude Include="..\..\src\imgui_impl_opengl3.h" />
+    <ClInclude Include="..\..\src\NativeWindow.hpp" />
+    <ClInclude Include="..\..\src\ResolvService.hpp" />
+    <ClInclude Include="..\..\src\stb_image.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Natvis Include="DebugVis.natvis" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Tracy.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Manifest Include="Tracy.manifest" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

3rdparty/tracy/profiler/build/win32/Tracy.vcxproj.filters

@@ -0,0 +1,591 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="common">
+      <UniqueIdentifier>{8037a17e-7618-45b1-9aac-07468070b713}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="server">
+      <UniqueIdentifier>{396d39d8-ca94-4e03-b965-701fa882efcb}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src">
+      <UniqueIdentifier>{478ff7b3-4f0f-4121-8b3c-e48896be7606}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="imgui">
+      <UniqueIdentifier>{474aec57-4ecd-467e-aecb-cdc4f41254ff}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="gl3w">
+      <UniqueIdentifier>{ec4b32ba-a8c9-49e8-9625-8cb15feccd8a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="nfd">
+      <UniqueIdentifier>{46eb6aa0-de1c-447a-a6dd-aee2a06f85ef}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="imgui\freetype">
+      <UniqueIdentifier>{1a9a9fea-82b2-41df-9d0e-ef4b00ed1213}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd">
+      <UniqueIdentifier>{92617c31-3733-464e-ab7d-30e664b1a95e}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\common">
+      <UniqueIdentifier>{b0b23052-a6aa-4827-a635-f2d50a7023b2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\compress">
+      <UniqueIdentifier>{b0067fb7-ac56-4ab6-a6b6-c6606f924212}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\decompress">
+      <UniqueIdentifier>{c93ef7c5-f1df-40a6-a4e3-81441e6df174}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\dictBuilder">
+      <UniqueIdentifier>{200ab875-91e5-4c7a-8b98-ddbae19d2f98}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySystem.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyView.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\main.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\NativeWindow.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\libs\gl3w\GL\gl3w.c">
+      <Filter>gl3w</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\nfd\nfd_common.c">
+      <Filter>nfd</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\nfd\nfd_win.cpp">
+      <Filter>nfd</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyBadVersion.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\winmain.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\winmainArchDiscovery.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyStorage.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\imgui_impl_glfw.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\imgui_impl_opengl3.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\imgui\imgui.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\imgui\imgui_demo.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\imgui\imgui_draw.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\imgui\imgui_widgets.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTexture.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\ResolvService.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyUserData.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracySourceView.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyColor.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyFilesystem.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMicroArchitecture.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMouse.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\HttpRequest.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyStackFrames.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\imgui\imgui_tables.cpp">
+      <Filter>imgui</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\imgui\misc\freetype\imgui_freetype.cpp">
+      <Filter>imgui\freetype</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracySourceTokenizer.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracySourceContents.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\debug.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\error_private.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\pool.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\threading.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\hist.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySocket.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySystem.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySlab.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVector.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyView.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\libs\gl3w\GL\gl3w.h">
+      <Filter>gl3w</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\libs\gl3w\GL\glcorearb.h">
+      <Filter>gl3w</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyImGui.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\nfd\common.h">
+      <Filter>nfd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\nfd\nfd.h">
+      <Filter>nfd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\nfd\nfd_common.h">
+      <Filter>nfd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\tracy_pdqsort.h">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileHeader.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyBadVersion.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVarArray.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyMutex.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Arimo.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVersion.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyStringDiscovery.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyDecayValue.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFilesystem.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\FontAwesomeSolid.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\Cousine.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyBuzzAnim.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\IconsFontAwesome5.h">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyStorage.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\imgui_impl_glfw.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\imgui_impl_opengl3.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\imconfig.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\imgui.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\imgui_internal.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\imstb_rectpack.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\imstb_textedit.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\imstb_truetype.h">
+      <Filter>imgui</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\icon.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\stb_image.h">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTexture.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\ResolvService.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyUserData.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyViewData.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyShortPtr.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\tracy_xxh3.h">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyYield.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySort.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\tracy_robin_hood.h">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySourceView.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyColor.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMicroArchitecture.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMouse.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\NativeWindow.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\src\HttpRequest.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyStackFrames.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySortedVector.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\imgui\misc\freetype\imgui_freetype.h">
+      <Filter>imgui\freetype</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySourceTokenizer.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySourceContents.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\compiler.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\cpu.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\debug.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\error_private.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\fse.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\huf.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\mem.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\pool.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\threading.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\hist.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zdict.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Natvis Include="DebugVis.natvis" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="Tracy.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Manifest Include="Tracy.manifest" />
+  </ItemGroup>
+</Project>

3rdparty/tracy/update/build/unix/Makefile

@@ -0,0 +1,12 @@
+all: release
+
+debug:
+	@+make -f debug.mk all
+
+release:
+	@+make -f release.mk all
+
+clean:
+	@+make -f build.mk clean
+
+.PHONY: all clean debug release

3rdparty/tracy/update/build/unix/build.mk

@@ -0,0 +1,12 @@
+CFLAGS +=
+CXXFLAGS := $(CFLAGS) -std=gnu++17
+DEFINES += -DTRACY_NO_STATISTICS
+INCLUDES := $(shell pkg-config --cflags capstone)
+LIBS := $(shell pkg-config --libs capstone) -lpthread
+PROJECT := update
+IMAGE := $(PROJECT)-$(BUILD)
+
+FILTER :=
+include ../../../common/src-from-vcxproj.mk
+
+include ../../../common/unix.mk

3rdparty/tracy/update/build/unix/debug.mk

@@ -0,0 +1,11 @@
+ARCH := $(shell uname -m)
+
+CFLAGS := -g3 -Wall
+DEFINES := -DDEBUG
+BUILD := debug
+
+ifeq ($(ARCH),x86_64)
+CFLAGS += -msse4.1
+endif
+
+include build.mk

3rdparty/tracy/update/build/unix/release.mk

@@ -0,0 +1,6 @@
+CFLAGS := -O3 -flto
+DEFINES := -DNDEBUG
+BUILD := release
+
+include ../../../common/unix-release.mk
+include build.mk

3rdparty/tracy/update/build/win32/update.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30907.101
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "update", "update.vcxproj", "{447D58BF-94CD-4469-BB90-549C05D03E00}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.ActiveCfg = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Debug|x64.Build.0 = Debug|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.ActiveCfg = Release|x64
+		{447D58BF-94CD-4469-BB90-549C05D03E00}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3E51386C-43EA-44AC-9F24-AFAFE4D63ADE}
+	EndGlobalSection
+EndGlobal

3rdparty/tracy/update/build/win32/update.vcxproj

@@ -0,0 +1,196 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{447D58BF-94CD-4469-BB90-549C05D03E00}</ProjectGuid>
+    <RootNamespace>update</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <VcpkgTriplet>x64-windows-static</VcpkgTriplet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>TRACY_NO_STATISTICS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\debug\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PreprocessorDefinitions>TRACY_NO_STATISTICS;NDEBUG;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;WIN32_LEAN_AND_MEAN;NOMINMAX;_USE_MATH_DEFINES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnableEnhancedInstructionSet>AdvancedVectorExtensions2</EnableEnhancedInstructionSet>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+      <AdditionalIncludeDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include;..\..\..\vcpkg\vcpkg\installed\x64-windows-static\include\capstone;$(VcpkgInstalledDir)$(VcpkgTriplet)\include\capstone</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>ws2_32.lib;capstone.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <AdditionalLibraryDirectories>..\..\..\vcpkg\vcpkg\installed\x64-windows-static\lib</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp" />
+    <ClCompile Include="..\..\..\common\TracySystem.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp" />
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp" />
+    <ClCompile Include="..\..\..\getopt\getopt.c" />
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp" />
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp" />
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp" />
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp" />
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp" />
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp" />
+    <ClCompile Include="..\..\..\zstd\common\debug.c" />
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c" />
+    <ClCompile Include="..\..\..\zstd\common\error_private.c" />
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\common\pool.c" />
+    <ClCompile Include="..\..\..\zstd\common\threading.c" />
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c" />
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c" />
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\hist.c" />
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c" />
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c" />
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c" />
+    <ClCompile Include="..\..\src\update.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp" />
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp" />
+    <ClInclude Include="..\..\..\common\TracyColor.hpp" />
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp" />
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp" />
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp" />
+    <ClInclude Include="..\..\..\common\TracySocket.hpp" />
+    <ClInclude Include="..\..\..\common\TracySystem.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp" />
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp" />
+    <ClInclude Include="..\..\..\getopt\getopt.h" />
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp" />
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp" />
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp" />
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp" />
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp" />
+    <ClInclude Include="..\..\..\server\TracySlab.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp" />
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp" />
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp" />
+    <ClInclude Include="..\..\..\server\TracyVector.hpp" />
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp" />
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h" />
+    <ClInclude Include="..\..\..\zstd\common\compiler.h" />
+    <ClInclude Include="..\..\..\zstd\common\cpu.h" />
+    <ClInclude Include="..\..\..\zstd\common\debug.h" />
+    <ClInclude Include="..\..\..\zstd\common\error_private.h" />
+    <ClInclude Include="..\..\..\zstd\common\fse.h" />
+    <ClInclude Include="..\..\..\zstd\common\huf.h" />
+    <ClInclude Include="..\..\..\zstd\common\mem.h" />
+    <ClInclude Include="..\..\..\zstd\common\pool.h" />
+    <ClInclude Include="..\..\..\zstd\common\threading.h" />
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h" />
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h" />
+    <ClInclude Include="..\..\..\zstd\compress\hist.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h" />
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h" />
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h" />
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h" />
+    <ClInclude Include="..\..\..\zstd\zdict.h" />
+    <ClInclude Include="..\..\..\zstd\zstd.h" />
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

3rdparty/tracy/update/build/win32/update.vcxproj.filters

@@ -0,0 +1,342 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="src">
+      <UniqueIdentifier>{729c80ee-4d26-4a5e-8f1f-6c075783eb56}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="server">
+      <UniqueIdentifier>{cf23ef7b-7694-4154-830b-00cf053350ea}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="common">
+      <UniqueIdentifier>{e39d3623-47cd-4752-8da9-3ea324f964c1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="getopt">
+      <UniqueIdentifier>{74a14f40-f52d-41c1-8b19-1f8bf2a7c9c7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd">
+      <UniqueIdentifier>{40f983b8-059b-4eb4-b8ed-af6bd709c264}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\common">
+      <UniqueIdentifier>{4ff9626a-71f8-4c7b-b940-928709e34950}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\compress">
+      <UniqueIdentifier>{28c6483b-84eb-495c-9c98-e830545a232f}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\decompress">
+      <UniqueIdentifier>{aeb60a40-d098-408e-a8c6-3de1c75cd9b4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="zstd\dictBuilder">
+      <UniqueIdentifier>{375ceb06-6b2f-4a00-af80-64d17bcadaac}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\common\tracy_lz4.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySocket.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\TracySystem.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMemory.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyWorker.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\src\update.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\common\tracy_lz4hc.cpp">
+      <Filter>common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyThreadCompress.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTaskDispatch.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyPrint.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyMmap.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\server\TracyTextureCompression.cpp">
+      <Filter>server</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\getopt\getopt.c">
+      <Filter>getopt</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\huf_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_ddict.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\decompress\zstd_decompress_block.c">
+      <Filter>zstd\decompress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\fse_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\hist.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\huf_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_literals.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_sequences.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_compress_superblock.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_double_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_fast.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_lazy.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_ldm.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstd_opt.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\compress\zstdmt_compress.c">
+      <Filter>zstd\compress</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\debug.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\entropy_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\error_private.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\fse_decompress.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\pool.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\threading.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\xxhash.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\common\zstd_common.c">
+      <Filter>zstd\common</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\cover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\divsufsort.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\fastcover.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\zstd\dictBuilder\zdict.c">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\common\tracy_lz4.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlloc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyColor.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyForceInline.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyProtocol.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyQueue.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySocket.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracySystem.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyCharUtil.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyEvent.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileWrite.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMemory.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPopcnt.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracySlab.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyVector.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyWorker.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\TracyAlign.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\common\tracy_lz4hc.hpp">
+      <Filter>common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyThreadCompress.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTaskDispatch.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyPrint.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyFileRead.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyMmap.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\server\TracyTextureCompression.hpp">
+      <Filter>server</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\getopt\getopt.h">
+      <Filter>getopt</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zstd_errors.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_ddict.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_block.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\decompress\zstd_decompress_internal.h">
+      <Filter>zstd\decompress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\hist.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_internal.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_literals.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_sequences.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_compress_superblock.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_cwksp.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_double_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_fast.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_lazy.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_ldm_geartab.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstd_opt.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\compress\zstdmt_compress.h">
+      <Filter>zstd\compress</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\bitstream.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\compiler.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\cpu.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\debug.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\error_private.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\fse.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\huf.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\mem.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\pool.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\threading.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\xxhash.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_deps.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_internal.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\common\zstd_trace.h">
+      <Filter>zstd\common</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\zdict.h">
+      <Filter>zstd</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\cover.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\zstd\dictBuilder\divsufsort.h">
+      <Filter>zstd\dictBuilder</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>