Hello ! I'm using ImGuizmo with GLFW and Vulkan. The code is working flawlessly on Windows, but not on Linux. The Guizmo is wrongly positioned (I'm currently selecting the white plane);

The model matrix :

(1.000000, 0.000000, 0.000000, 0.000000), 
(0.000000, 1.000000, 0.000000, 0.000000),
(0.000000, 0.000000, 1.000000, 0.000000),
(0.000000, 0.000000, 0.000000, 1.000000)

ImGuizmo::Manipulate(glm::value_ptr(cameraView), glm::value_ptr(cameraProjection), ImGuizmo::TRANSLATE , ImGuizmo::LOCAL, glm::value_ptr(object.getModelMatrix());

object.getModelMatrix() return a reference to the model matrix. The object transform is stored has the model matrix directly. cameraProjection is created with glm::projection cameraView is created with glm::lookAt

After the call to manipulate, the model matrix is set to NaN most of the time.

My Translation and Scaling Gizmos work fine and are oriented in the right way. My Rotation Gizmo works more or less but the orientation is messed up, as you can see below:

I have no idea what might be wrong because the other two gizmos are displayed correctly(I use OpenGL's right handed coordinate system):

What might be the Issue? Thanks in advance.

Hi, the closer I am to the object, the more guizmo is centered and the further I go backwards, the more it bends, it is normal? https://user-images.githubusercontent.com/82084934/129267758-0bd2f7b1-8049-43bb-9cab-d2ba7d119795.mp4

Hello, I have difficulties with the rotation guizmo, when I get the matrix from the manipulate function, I get results which vary from frame to frame, and which do not rotate the object correctly, sometimes even do not rotate the object at all. The translation and scale works good. Can you help me ? Thank you

Hey,

I've tried implementing this wonderful little library but for reasons I don't understand the gizmo behaves not the way I'd expect it to. Instead of sticking to the object that I want to manipulate, it seems to incorporate the distance to the camera giving it a weird offset to the object from greater distances. Here's what I mean:

I've looked into other issues that seemed to be related to this one and the common fix is to properly call ImGuizmo::SetRect but no matter what I try the behaviour doesn't change.

Here's my code:

        void draw_gizmo(scene::scene& scene, ImVec2 const& panel_size)
        {
            auto selected_entity = scene.selected_entity();
            if (selected_entity)
            {
                return;
            }

            ImGuizmo::SetOrthographic(false);
            ImGuizmo::SetDrawlist();

            auto viewportMinRegion = ImGui::GetWindowContentRegionMin();
            auto viewportMaxRegion = ImGui::GetWindowContentRegionMax();
            auto viewportOffset = ImGui::GetWindowPos();
            auto size = ImGui::GetWindowSize();
            auto min = glm::vec2{viewportMinRegion.x + viewportOffset.x, viewportMinRegion.y + viewportOffset.y};
            auto max =
                glm::vec2{viewportMaxRegion.x + viewportOffset.x, viewportMaxRegion.y - viewportOffset.y / 2};
            ImGuizmo::SetRect(min.x, min.y, max.x, max.y);

            glm::ivec2 isize;
            glfwGetWindowSize(glfwGetCurrentContext(), &isize.x, &isize.y);
            // ImGuizmo::SetRect(viewportOffset.x, viewportOffset.y, isize.x, isize.y);

            ImVec2 windowSize = ImGui::GetWindowSize();
            // ImGuizmo::SetRect(viewportOffset.x, viewportOffset.y, windowSize.x, windowSize.y);
            // ImGuizmo::SetRect(viewportOffset.x, viewportOffset.y, panel_size.x, panel_size.y);

            auto camera_entity = scene.active_camera();
            auto const& camera_component = camera_entity.get_component<scene::camera_component>();

            auto projection = camera_component.projection();
            auto view = camera_component.view();
            auto& transform_component = selected_entity->get_component<scene::transform_component>();
            auto& transform = transform_component.transform();

            float snap[3] = {0.5f, 0.5f, 0.5f};

            if (ImGuizmo::Manipulate(glm::value_ptr(view), glm::value_ptr(projection), ImGuizmo::TRANSLATE,
                                     ImGuizmo::LOCAL, glm::value_ptr(transform), nullptr, snap))
            {
                glm::vec3 scale;
                glm::quat rotation;
                glm::vec3 translation;
                glm::vec3 skew;
                glm::vec4 perspective;

                if (glm::decompose(transform, scale, rotation, translation, skew, perspective))
                {
                    rotation = glm::conjugate(rotation);

                    transform_component.translation() = translation;
                    transform_component.rotation() = glm::radians(glm::eulerAngles(rotation));
                    transform_component.scale() = scale;
                    transform_component.recalculate_transform();
                }
            }
        }
    }

As you can see from the commented-out lines I've tried a number of different versions of ImGuizmo::SetRect (and pretty much any thinkable permutation).

Some more info:

• I'm using the docking branch of imgui
• I'm using glm as my math library

I'm at a total loss and this is a last ditch effort before I have to implement my own gizmos.

So far i am unable to get ViewManipulate() to orbit object.

Code im using:

Camera* camera = GetCamera();
Node* cameraNode = camera->GetNode();
float length = 10;
Matrix4 view = camera->GetView().ToMatrix4().Transpose();
ImGuizmo::ViewManipulate(&view.m00_, length, pos, size, 0);
cameraNode->SetWorldTransform(Matrix3x4(view.Transpose().Inverse()));

Conventions of the engine: Left-handed coordinates. Positive X, Y & Z axes point to the right, up, and forward, and positive rotation is clockwise, column-major matrices.

It seems as if camera is rotating a point behind it..? Here is a video: ViewManipulate-rotation.zip

Do you think this could be a mismatch between conventions that engine uses and conventions that ViewManipulate() expects?

Me and @GlynLeine discovered a little issue with the Rotation Gizmo that struck us as rather odd This is the issue we encountered: As you can see we are only able to use the gizmo from the parts we cannot actually see. We made an adjusment to line number 1661 of ImGuizmo.cpp which seems to fix this issue:

//was
if (Dot(Normalized(localPos), gContext.mRayVector) > FLT_EPSILON)
//now
if (Dot(Normalized(localPos), gContext.mRayVector) < -FLT_EPSILON)

As demonstrated here:

Hello, translation axis isnt responding, highlighted, when cursor is over, scale and rotation axis work fine though. There is no issue when i apply SetRect func position to zero. Probably i'm missing something, thanks.

ImGui::Image(SCENE_RENDER_TEXTURE, data.WindowScale);

ImVec2 panelSize = ImGui::GetContentRegionAvail();
ImGuizmo::Enable(true);
ImGuizmo::SetOrthographic(false);
ImGuizmo::SetDrawlist();
ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, panelSize.x, panelSize.y);

ImGuizmo::Manipulate(data.view, data.projection, operation, ImGuizmo::MODE::LOCAL, data.matrix);

I'm working with DIRECTX11 and docking, if I remove first line of this code, I can see gizmo but, somehow my scene render texture is blocking imguizmo this is with scene render texture this is without scene render texture

I have an issue with my rotation, the translation and scale is working with issues but when I'm trying the rotation the object seems "stuck". Here is how it looks: https://gyazo.com/dd412eb7bcbd282f4fb6f97bb0d9b1c9

I tried to using the ImGuizmos built in RecomposeMatrixFromComponents and then DecomposeMatrixToComponents before loading it back into my transformation component. The issue I got then were that the rotation seemed to be giving me values between 0 to 20000. Here is the relevant code:

// Editor Camera
DirectX::XMFLOAT4X4 cameraProjection;
DirectX::XMStoreFloat4x4(&cameraProjection, mEditorCamera->GetProjection());
DirectX::XMFLOAT4X4 cameraView;
DirectX::XMStoreFloat4x4(&cameraView, mEditorCamera->GetViewMatrix());

// Entity transform
auto& tc = selectedEntity.GetComponent<TransformComponent>();
DirectX::XMFLOAT4X4 transform;
DirectX::XMStoreFloat4x4(&transform, tc.GetTransform());
//float Ftranslation[3] = { tc.Translation.x, tc.Translation.y, tc.Translation.z };
//float Frotation[3] = { tc.Rotation.x, tc.Rotation.y, tc.Rotation.z };
//float Fscale[3] = { tc.Scale.x, tc.Scale.y, tc.Scale.z };
//ImGuizmo::RecomposeMatrixFromComponents(Ftranslation, Frotation, Fscale, *transform.m);

ImGuizmo::Manipulate(*cameraView.m, *cameraProjection.m, (ImGuizmo::OPERATION)mGizmoType, ImGuizmo::LOCAL, *transform.m);
if (ImGuizmo::IsUsing())
{
	TOAST_CORE_INFO("tc.Rotation.x: {0}", tc.Rotation.x);
	TOAST_CORE_INFO("tc.Rotation.y: {0}", tc.Rotation.y);
	TOAST_CORE_INFO("tc.Rotation.z: {0}\n", tc.Rotation.z);

	DirectX::XMMATRIX test = DirectX::XMLoadFloat4x4(&transform);

	DirectX::XMVECTOR translation, rotation, scale;
	DirectX::XMMatrixDecompose(&scale, &rotation, &translation, test);
	float F2translation[3] = { 0.0f, 0.0f, 0.0f };
	float F2rotation[3] = { 0.0f, 0.0f, 0.0f };
	float F2scale[3] = { 0.0f, 0.0f, 0.0f };
	ImGuizmo::DecomposeMatrixToComponents(*transform.m, F2translation, F2rotation, F2scale);

	DirectX::XMFLOAT3 xmfTranslation = DirectX::XMFLOAT3(F2translation);
	DirectX::XMFLOAT3 xmfScale = DirectX::XMFLOAT3(F2scale);
	DirectX::XMFLOAT3 xmfRotation = DirectX::XMFLOAT3(F2rotation);

	//tc.Translation = xmfTranslation;
	//tc.Rotation = xmfRotation;
	//tc.Scale = xmfScale;

	DirectX::XMStoreFloat3(&tc.Translation, translation);
	DirectX::XMStoreFloat3(&tc.Rotation, rotation);
	DirectX::XMStoreFloat3(&tc.Scale, scale);
}

I have issue finding examples of people that tried to do the same so I have little to go on

I'm trying to use your library for my engine, but I can't properly integrate it. I have that rendering model: Scene -> Hierarchy -> GameObject -> Transform { position, rotation, scale } + EditorCamera as a GameObject When I select a GameObject in hierarchy, I expect to edit its transform, but:

1. I cannot properly build matrices for ImGuizmo (Maybe I'm so stupid, but nothing I tried helps me)
2. It render grid and maybe something else orthographically
3. Even if I get some success, ImGuizmo renders on the background(behind all windows, but I need to render it over the render window only)

Screenshots:

Code of transform editing function:

void EditTransform(Transform* t)
    {
        auto cam = EditorInstance::GetSingleton()->currentScene->Get("Editor Camera");
        auto camCmp = cam->GetComponent<Camera>();

        ImGuizmo::SetOrthographic(false);
        ImGuizmo::BeginFrame();
        ImGuizmo::Enable(true);


        ImGuiIO& io = ImGui::GetIO();
        ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);

        float* _view = new float[16];
        glm::mat4 mmat = glm::mat4();
        glm::translate(mmat, glm::vec3{t->globalPosition().x, t->globalPosition().y, t->globalPosition().z});
        glm::scale(mmat, glm::vec3{t->scale.x, t->scale.y, t->scale.z});
        glm::rotate(mmat, (float)t->rotation.x , glm::vec3{1, 0, 0});
        glm::rotate(mmat, (float)t->rotation.y , glm::vec3{0, 1, 0});
        glm::rotate(mmat, (float)t->rotation.z , glm::vec3{0, 0, 1});
        
        // ==> WHAT AM I DOING WRONG? NOTHING OF NEXT WORKS PROPERLY.
        //_view =(float*)glm::value_ptr(mmat);
        glGetFloatv(GL_MODELVIEW_MATRIX, _view);
        glm::fmat4 view = glm::mat4(*_view);

        float* _proj = new float[16];
        glm::mat4 pmat = glm::perspectiveFov(camCmp->fov, io.DisplaySize.x, io.DisplaySize.y, camCmp->_near, camCmp->_far);

//  ==> AND HERE TOO
//        _proj = (float*)glm::value_ptr(pmat);
//        glGetFloatv(GL_PROJECTION_MATRIX, _proj);
        glm::fmat4 projection = pmat; //(*_proj);


        auto matrix = glm::lookAt(
            glm::vec3{ cam->transform.globalPosition().x, cam->transform.globalPosition().y, cam->transform.globalPosition().z },
//            { t->globalPosition().x, t->globalPosition().y, t->globalPosition().z },
            { cam->transform.globalPosition().x + cam->transform.direction().x, cam->transform.globalPosition().y + cam->transform.direction().y, cam->transform.globalPosition().z + cam->transform.direction().z },
            { 0, 1, 0});

        ImGuizmo::DrawGrid(&view[0][0], &projection[0][0], &matrix[0][0], 200.0f);
        ImGuizmo::Manipulate(&view[0][0], &projection[0][0], ImGuizmo::TRANSLATE, ImGuizmo::WORLD, &matrix[0][0], NULL, NULL);
    }

Code of render window function:

 void winRender(){
        ImGui::Begin("Render", &win->render, window_flags);
        ImVec2 pos = ImGui::GetWindowPos();
        auto tex = dynamic_cast<NukeOGL*>(EditorInstance::GetSingleton()->render)->getRenderTexture();
        ImVec2 maxPos = ImVec2(pos.x + ImGui::GetWindowSize().x, pos.y + ImGui::GetWindowSize().y + 2);
        ImGui::GetWindowDrawList()->AddImage((void *)tex,
                                             ImVec2(ImGui::GetItemRectMin().x + 0,
                                            ImGui::GetItemRectMin().y - 2),
                                             maxPos, ImVec2(0,1), ImVec2(1,0));
        if(EditorInstance::GetSingleton()->selectedInHieararchy){
           EditTransform(&EditorInstance::GetSingleton()->selectedInHieararchy->transform);
        }

        ImGui::End();
    }

I'm sure I'm doing something wrong but I can't figure out what. I have an orthographic projection like this

m_AspectRatio = (float)width / (float)height;
float orthoLeft = 0.0f;
float orthoRight = (float)m_OrthographicHeight * m_AspectRatio * m_Zoom;
float orthoTop = (float)m_OrthographicHeight * m_Zoom;
float orthoBottom = 0.0f;

m_Projection = glm::ortho(orthoLeft, orthoRight, orthoBottom, orthoTop, (float)m_OrthographicNear, (float)m_OrthographicFar);

glm::mat4 transformationMatrix = glm::translate(glm::mat4(1.0f), m_Position);

m_View = glm::inverse(transformationMatrix);

The camera doesn't rotate and stays at z = 10 but the y axis for the guizmo is inverted. It is pointing the wrong direction and drags in the wrong direction.

Hi,

I encountered a small problem regarding mouse input when rendering manipluate gizmos over other UI elements that react to mouse input.

I am rendering an invisible ButtonBehavior over the scene view to capture mouse inputs for things like object picking and camera movement. The overlay buttons in the top left are still working correctly (due to ImGuiButtonFlags_AllowItemOverlap) but the manipulate gizmos are not. When the ButtonBehavior is present they only react correctly when hovering them but you cannot actually manipulate the object.

const ImRect textureRect = ImGui::GetCurrentWindow()->InnerClipRect;
ImGui::GetBackgroundDrawList()->AddImage(textureId, textureRect.Min, textureRect.Max);

const ImRect rect = ImGui::GetCurrentWindow()->InnerClipRect;
const ImGuiID id = ImGui::GetCurrentWindow()->GetID("SceneViewButton");
ImGui::ItemAdd(rect, id);
ImGui::ButtonBehavior(rect, id, nullptr, nullptr, ImGuiButtonFlags_PressedOnClick | ImGuiButtonFlags_AllowItemOverlap | ImGuiButtonFlags_MouseButtonMask_);
ImGui::SetItemAllowOverlap();
                
ImGuizmo::SetDrawlist();

const glm::uvec2 position = EditorGui::GetWindowPosition();
const glm::uvec2 size = EditorGui::GetWindowSize();
ImGuizmo::SetRect(static_cast<float>(position.x), static_cast<float>(position.y), 
                    static_cast<float>(size.x), static_cast<float>(size.y));

//ImGuizmo::Manipulate calls follow here

It's about the orthographic mode and shifting on the x axis

Thread 1 "vengi-voxedit" received signal SIGFPE, Arithmetic exception.
ImGuizmo::ComputeContext (view=0x55555859e620, projection=0x55555859e6a0, matrix=0x7fffffffc500, mode=ImGuizmo::LOCAL) at /home/mgerhardy/dev/engine/src/modules/ui/dearimgui/ImGuizmo.cpp:1070
1070	      gContext.mScreenFactor = gContext.mGizmoSizeClipSpace / (pointRight.x / pointRight.w - gContext.mMVP.v.position.x / gContext.mMVP.v.position.w);
(gdb) bt
#0  ImGuizmo::ComputeContext (view=0x55555859e620, projection=0x55555859e6a0, matrix=0x7fffffffc500, mode=ImGuizmo::LOCAL) at /home/mgerhardy/dev/engine/src/modules/ui/dearimgui/ImGuizmo.cpp:1070
#1  0x00005555558e5205 in ImGuizmo::Manipulate (view=0x55555859e620, projection=0x55555859e6a0, operation=2047, mode=ImGuizmo::LOCAL, matrix=0x7fffffffc500, deltaMatrix=0x7fffffffc540, snap=0x7fffffffc4e8, localBounds=0x55555859b6dc, boundsSnap=0x7fffffffc4f4)
    at /home/mgerhardy/dev/engine/src/modules/ui/dearimgui/ImGuizmo.cpp:2487
#2  0x00005555555b7fd1 in voxedit::Viewport::renderSceneGuizmo (this=0x55555859b680, camera=...) at /home/mgerhardy/dev/engine/src/tools/voxedit/modules/voxedit-ui/Viewport.cpp:324
#3  0x00005555555b8760 in voxedit::Viewport::renderGizmo (this=0x55555859b680, camera=..., headerSize=23.8817329, size=...) at /home/mgerhardy/dev/engine/src/tools/voxedit/modules/voxedit-ui/Viewport.cpp:411
#4  0x00005555555b71f1 in voxedit::Viewport::update (this=0x55555859b680) at /home/mgerhardy/dev/engine/src/tools/voxedit/modules/voxedit-ui/Viewport.cpp:163
#5  0x00005555555a5122 in voxedit::MainWindow::mainWidget (this=0x555557e73750) at /home/mgerhardy/dev/engine/src/tools/voxedit/modules/voxedit-ui/MainWindow.cpp:198
#6  0x00005555555a646e in voxedit::MainWindow::update (this=0x555557e73750) at /home/mgerhardy/dev/engine/src/tools/voxedit/modules/voxedit-ui/MainWindow.cpp:448
#7  0x0000555555599df2 in VoxEdit::onRenderUI (this=0x7fffffffcd70) at /home/mgerhardy/dev/engine/src/tools/voxedit/VoxEdit.cpp:289
#8  0x00005555557c26e6 in ui::IMGUIApp::onRunning (this=0x7fffffffcd70) at /home/mgerhardy/dev/engine/src/modules/ui/IMGUIApp.cpp:388
#9  0x0000555555599e0e in VoxEdit::onRunning (this=0x7fffffffcd70) at /home/mgerhardy/dev/engine/src/tools/voxedit/VoxEdit.cpp:293
#10 0x000055555595f2cf in app::App::onFrame (this=0x7fffffffcd70) at /home/mgerhardy/dev/engine/src/modules/app/App.cpp:165
#11 0x000055555595eefb in app::App::startMainLoop (this=0x7fffffffcd70, argc=1, argv=0x7fffffffdde8) at /home/mgerhardy/dev/engine/src/modules/app/App.cpp:90
#12 0x0000555555599f18 in main (argc=1, argv=0x7fffffffdde8) at /home/mgerhardy/dev/engine/src/tools/voxedit/VoxEdit.cpp:314
(gdb) l
1065	       gContext.mReversed = (nearPos.z/nearPos.w) > (farPos.z / farPos.w);
1066	
1067	      // compute scale from the size of camera right vector projected on screen at the matrix position
1068	      vec_t pointRight = viewInverse.v.right;
1069	      pointRight.TransformPoint(gContext.mViewProjection);
1070	      gContext.mScreenFactor = gContext.mGizmoSizeClipSpace / (pointRight.x / pointRight.w - gContext.mMVP.v.position.x / gContext.mMVP.v.position.w);
1071	
1072	      vec_t rightViewInverse = viewInverse.v.right;
1073	      rightViewInverse.TransformVector(gContext.mModelInverse);
1074	      float rightLength = GetSegmentLengthClipSpace(makeVect(0.f, 0.f), rightViewInverse);
(gdb) p pointRight
$1 = {x = -0.393480003, y = -0.721848011, z = -0.96603936, w = 1}
(gdb) p gContext.mMVP.v.position.w
$2 = 1
(gdb) p gContext.mMVP.v.position.x
$3 = -0.393480003
(gdb) p (pointRight.x / pointRight.w - gContext.mMVP.v.position.x / gContext.mMVP.v.position.w)
$4 = 0
(gdb) p gContext.mGizmoSizeClipSpace 
$5 = 0.100000001

Hello, the current vcpkg port of ImGuizmo is based on the latest release version (1.83) which date from more that a year. I would like to update it, but the vcpkg team insist on the use of libraries official releases instead of the latest commit. Is it possible to create a new ImGuizmo release so I can update the vcpkg port?

When i take latest ImGuizmo.cpp from examples in my engine gizmo scale broken.

Translation and rotation working fine, but when, i use scale mode and scale object, its brokes.

When I scale an object, the axis along which I scale in ImGuizmo is stretched and it turns out in all modes I have Guizmo rendered incorrectly (stretched), although the area where I can select the gizmo axis for manipulation shows correctly. I haven't changed anything in the Guizmo code and engine, well, except for the style. In version 1.62, I have everything rendered normally with the same code, but in the latest version, this is the problem.