mirror of
https://github.com/aap/librw.git
synced 2024-11-25 13:15:43 +00:00
273 lines
12 KiB
C++
273 lines
12 KiB
C++
// https://github.com/CedricGuillemet/ImGuizmo
|
|
// v 1.89 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
|
|
|
|
#ifndef IMGUIZMO_NAMESPACE
|
|
#define IMGUIZMO_NAMESPACE ImGuizmo
|
|
#endif
|
|
|
|
namespace IMGUIZMO_NAMESPACE
|
|
{
|
|
// 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();
|
|
|
|
// return true if any gizmo is in moving state
|
|
IMGUI_API bool IsUsingAny();
|
|
|
|
// 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);
|
|
|
|
// use this version if you did not call Manipulate before and you are just using ViewManipulate
|
|
IMGUI_API void ViewManipulate(float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, 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);
|
|
|
|
// Configure the limit where axis are hidden
|
|
IMGUI_API void SetAxisLimit(float value);
|
|
// Configure the limit where planes are hiden
|
|
IMGUI_API void SetPlaneLimit(float value);
|
|
|
|
enum COLOR
|
|
{
|
|
DIRECTION_X, // directionColor[0]
|
|
DIRECTION_Y, // directionColor[1]
|
|
DIRECTION_Z, // directionColor[2]
|
|
PLANE_X, // planeColor[0]
|
|
PLANE_Y, // planeColor[1]
|
|
PLANE_Z, // planeColor[2]
|
|
SELECTION, // selectionColor
|
|
INACTIVE, // inactiveColor
|
|
TRANSLATION_LINE, // translationLineColor
|
|
SCALE_LINE,
|
|
ROTATION_USING_BORDER,
|
|
ROTATION_USING_FILL,
|
|
HATCHED_AXIS_LINES,
|
|
TEXT,
|
|
TEXT_SHADOW,
|
|
COUNT
|
|
};
|
|
|
|
struct Style
|
|
{
|
|
IMGUI_API Style();
|
|
|
|
float TranslationLineThickness; // Thickness of lines for translation gizmo
|
|
float TranslationLineArrowSize; // Size of arrow at the end of lines for translation gizmo
|
|
float RotationLineThickness; // Thickness of lines for rotation gizmo
|
|
float RotationOuterLineThickness; // Thickness of line surrounding the rotation gizmo
|
|
float ScaleLineThickness; // Thickness of lines for scale gizmo
|
|
float ScaleLineCircleSize; // Size of circle at the end of lines for scale gizmo
|
|
float HatchedAxisLineThickness; // Thickness of hatched axis lines
|
|
float CenterCircleSize; // Size of circle at the center of the translate/scale gizmo
|
|
|
|
ImVec4 Colors[COLOR::COUNT];
|
|
};
|
|
|
|
IMGUI_API Style& GetStyle();
|
|
}
|