public void Render(GLContext context, Vector3 position, bool[] isSelected)
        {
            var shader = GlobalShaders.GetShader("GIZMO");

            context.CurrentShader = shader;

            GL.Disable(EnableCap.DepthTest);

            //Scale from camera position
            float scale = 1.0f;
            // if (position.Length != 0)
            // scale *= (context.Camera.Translation.Length / position.Length) * 0.05f;

            var translateMtx = Matrix4.CreateTranslation(position);
            var scaleMtx     = Matrix4.CreateScale(scale);
            var transform    = scaleMtx * translateMtx;

            //Set a center cube
            context.CurrentShader.SetMatrix4x4("mtxMdl", ref transform);
            context.CurrentShader.SetVector4("color", new Vector4(1, 1, 1, 1));
            CubeRenderer.Draw(context, 0.255f);

            //Draw each axis object.
            var ray = context.PointScreenRay();

            for (int i = 0; i < 3; i++)
            {
                //Check ray hits inside bounding boxes
                DrawAxis(context, isSelected[i], ref transform, _endPostions[i], _rotations[i], _colors[i]);
            }

            context.CurrentShader = null;
            GL.Enable(EnableCap.DepthTest);
        }
Example #2
0
        private bool CheckSelectedAxes(GLContext context, Vector2 point)
        {
            if (!UseGizmo)
            {
                return(true);
            }

            var ray = context.PointScreenRay((int)point.X, (int)point.Y);

            var position = Transform.Position;
            var rotation = Transform.Rotation;

            CameraRay localRay = new CameraRay();

            localRay.Direction = Vector3.Transform(ray.Direction, rotation.Inverted());
            localRay.Origin    = new Vector4(Vector3.Transform(ray.Origin.Xyz - position, rotation.Inverted()), localRay.Origin.W);

            List <float> results = new List <float>();

            for (int i = 0; i < AxisOjects.Count; i++)
            {
                isSelected[i] = false;

                if (GLMath.RayIntersectsAABB(localRay, AxisOjects[i].Min, AxisOjects[i].Max, out float d))
                {
                    results.Add(d);
                    isSelected[i] = true;
                }
            }

            results.Sort((x, y) => x.CompareTo(y));

            if (results.Count == 0)
            {
                return(false);
            }

            Vector3 localHitPoint = localRay.Origin.Xyz + (localRay.Direction * results[0]);
            var     m_hitPoint    = Vector3.Transform(localHitPoint, Quaternion.Identity) + Transform.Position;

            return(true);
        }
Example #3
0
        public bool SetTransform(GLContext context, Vector2 point)
        {
            var ray = context.PointScreenRay((int)point.X, (int)point.Y);

            var axis = GLScene.Axis.None;

            for (int i = 0; i < 3; i++)
            {
                if (isSelected[i] || !UseGizmo)
                {
                    axis |= (GLScene.Axis)(i + 1);
                }
            }

            Console.WriteLine($"axis {axis}");

            var position    = Transform.Position;
            var rotation    = Transform.Rotation;
            var invRotation = rotation.Inverted();

            Vector3 dirToCamera = (position - context.Camera.TargetPosition).Normalized();

            Vector3 axisB = GetSelectedAxisVector3(axis);
            Vector3 axisA = Vector3.Cross(axisB, dirToCamera);

            Vector3 planeNormal      = Vector3.Cross(axisA, axisB).Normalized();
            var     translationPlane = new FustrumPlane(planeNormal, position);

            if (translationPlane.RayIntersectsPlane(ray, out float intersectDist))
            {
                Vector3 hitPos     = ray.Origin.Xyz + (ray.Direction * intersectDist);
                Vector3 localDelta = Vector3.Transform(hitPos - position, invRotation);

                Vector3 newPos = position;
                if (axis.HasFlag(GLScene.Axis.X))
                {
                    newPos += Vector3.Transform(Vector3.UnitX, rotation) * localDelta.X;
                }
                if (axis.HasFlag(GLScene.Axis.Y))
                {
                    newPos += Vector3.Transform(Vector3.UnitY, rotation) * localDelta.Y;
                }
                if (axis.HasFlag(GLScene.Axis.Z))
                {
                    newPos += Vector3.Transform(Vector3.UnitZ, rotation) * localDelta.Z;
                }

                Vector3 newPosDirToCamera = (newPos - context.Camera.TargetPosition).Normalized();
                float   dot = Math.Abs(Vector3.Dot(planeNormal, newPosDirToCamera));

                if (dot < 0.02f)
                {
                    return(false);
                }

                if (!m_hasSetMouseOffset)
                {
                    m_translateOffset   = position - newPos;
                    m_hasSetMouseOffset = true;
                    return(false);
                }

                var deltaTranslation = Vector3.Transform(newPos - position + m_translateOffset, rotation.Inverted());

                if (!axis.HasFlag(GLScene.Axis.X))
                {
                    deltaTranslation.X = 0f;
                }
                if (!axis.HasFlag(GLScene.Axis.Y))
                {
                    deltaTranslation.Y = 0f;
                }
                if (!axis.HasFlag(GLScene.Axis.Z))
                {
                    deltaTranslation.Z = 0f;
                }

                Transform.Position += Vector3.Transform(deltaTranslation, rotation);
            }
            else
            {
                // Our raycast missed the plane
                return(false);
            }

            return(true);
        }