LibGizmo is a small, standalone library that adds a 3D matrix (4x4 floats) manipulation control called 'Gizmo'

here's a way to not have the scaling gizmo always snap to zero scale when user start scaling non-uniformly

            if (m_ScaleType == SCALE_XYZ)
            {
                int difx = x - m_LockX;
                float lng2 = 1.0f + ( float(difx) / 200.0f);
                SnapScale(lng2);
                scVect *=lng2;
            }
            else
            {
                int difx = x - m_LockX;
                int dify = y - m_LockY;

                // modification start ////////////////////////////////////////////////////

                // original code...
                //float len = sqrtf( (float)(difx*difx) + (float)(dify*dify) );
                //float lng2 = len /100.f;

                // get location of object in screen space
                tmatrix viewproj = m_Model * m_Proj;
                tvector3 trans = m_pMatrix->GetTranslation();
                tvector4 wpos = vector4(trans.x, trans.y, trans.z, 1.f);
                wpos.Transform(viewproj);
                tvector2 spos(wpos.x/wpos.w, -(wpos.y/wpos.w));
                if(wpos.z < 0)
                    return;
                tvector2 screenPos(0,0);
                tvector2 screenSize((float)mScreenWidth, (float)mScreenHeight);
                tvector2 pos(screenPos.x + (1.f + spos.x)*(screenSize.x * .5f), (screenPos.y + (1.f + spos.y)*(screenSize.y * .5f)));

                // compare clicked pos and object pos to choose between x or y axis
                // and determine which direction is positive or negative
                float lng2;
                float distx = abs(m_LockX - pos.x);
                float disty = abs(m_LockY - pos.y);
                if(distx >= disty)
                {
                    if(m_LockX < pos.x)
                        lng2 = 1.0f - ( float(difx) / 100.0f);
                    else
                        lng2 = 1.0f + ( float(difx) / 100.0f);
                }
                else
                {
                    if(m_LockY < pos.y)
                        lng2 = 1.0f - ( float(dify) / 100.0f);
                    else
                        lng2 = 1.0f + ( float(dify) / 100.0f);
                }
                // modification end //////////////////////////////////////////////////////

                /*
                float lng2 = ( df.Dot(m_LockVertex));
                char tmps[512];
                sprintf(tmps, "%5.4f\n", lng2 );
                OutputDebugStringA( tmps );


                if (lng2 < 1.f)
                {
                    if ( lng2<= 0.001f )
                        lng2 = 0.001f;
                    else
                    {
                        //lng2+=4.f;
                        lng2/=5.f;
                    }
                }
                else
                {
                    int a = 1;
                }
                */
                SnapScale(lng2);
                scVect *= lng2;
                scVect += scVect2;
            }

To replicate this bug:

1. run the example executable
2. press 3 to switch to scale mode 3 scale along the red axis to make the cube into a long box
3. press 2 to switch to rotate mode
4. try rotate along all axis and observe how the box will be distorted after some rotation

Please let me know if you have question about the bug. I hope it is not a difficult fix :)

Not a critical bug, but this will allow the LOCATE_VIEW and LOCATE_WORLD mode for rotation gizmo a lot more useful. currently, rotation gizmo doesn't always rotate the object around the gizmo's "visual-axis"... meaning, the X-Y-Z arc rotate the object along the object's X-Y-Z axis, and after a few rotations, user will not be able to tell how the rotation axis is oriented (unless the gizmo is set to LOCAL mode). Ideally, regardless of whether the gizmo is in LOCAL, WORLD, or VIEW mode, the object should always rotate according to the visual arc visualized by the gizmo.

Thanks for a great lib, I found it very useful and I'm sure others will too. Keep up the great work!

Hi,

First of all, thanks for creating this lib. Love it, extremely useful. I hope you'll keep improving this lib :)

After trying out your lib, I've found a few bugs, but this one is the most important one. You can reproduce this bug easily by:

1. run the executable demo included with the lib
2. press 2 to switch to rotation gizmo
3. rotate the object, (just 90 degree around Y axis should be enough)
4. press 1 to switch back to move gizmo
5. move the cursor over all the gizmo's arrows
6. notice that the gizmo will no longer correctly detect collision between the cursor and the gizmo.

I might be wrong, but it looks like the collision detection is done as if the gizmo is set to LOCATE_LOCAL even when the gizmo is set to LOCATE_VIEW or LOCATE_WORLD

Hi,

It is, perhaps, not a great idea to include large binaries and intermediate build files (such as .ipch) in the git repository. It might be worth-while deleting this repository while it doesn't contain any history and re-uploading the source excluding all binaries (use .gitignore rules).

Pre-built versions of the library and example applications can be uploaded to github as a separate downloadable packages.

Thank you, Yuriy