public void AddJoint(PhysicsJointMain joint)
        {
            string bodyOne              = joint.BodyOne;
            string bodyTwo              = joint.BodyTwo;
            int    collisionGroup       = joint.CollisionGroup;
            bool   isAngleSpringEnabled = joint.AngleSpringEnabled;
            float  springConstant       = joint.AngleSpringConstant;
            float  dampeningConstant    = joint.AngleSpringDampningConstant;
            float  angleLowerLimit      = (float)joint.AngleLowerLimit;
            float  angleUpperLimit      = (float)joint.AngleUpperLimit;


            Point   center            = joint.GetCenter();
            Vector2 ptCollisionCenter = new Vector2((float)center.X, (float)center.Y);


            if (!PhysicsObjects.ContainsKey(bodyOne))
            {
                throw new Exception("Cannot add joint for an invalid BodyOne value of '" + bodyOne + "'. If using Behaviors, did you forgot to add a PhysicsObjectBehavior?");
            }
            if (!PhysicsObjects.ContainsKey(bodyTwo))
            {
                throw new Exception("Cannot add joint for an invalid BodyTwo value of '" + bodyTwo + "'. If using Behaviors, did you forgot to add a PhysicsObjectBehavior?");
            }

            Body body1 = PhysicsObjects[bodyOne].BodyObject;
            Body body2 = PhysicsObjects[bodyTwo].BodyObject;

            Geom          geom1         = PhysicsObjects[bodyOne].GeometryObject;
            Geom          geom2         = PhysicsObjects[bodyTwo].GeometryObject;
            RevoluteJoint revoluteJoint = JointFactory.Instance.CreateRevoluteJoint(Simulator, body1, body2, ptCollisionCenter);

            if (isAngleSpringEnabled)
            {
                AngleSpring angleSpring = new AngleSpring(body1, body2, springConstant, dampeningConstant);
                Simulator.Add(angleSpring);
            }

            if (angleUpperLimit != -1 && angleLowerLimit != -1)
            {
                float           upperAngle      = (float)DegreesToRadians(angleUpperLimit);
                float           lowerAngle      = (float)DegreesToRadians(angleLowerLimit);
                AngleLimitJoint angleLimitJoint = new AngleLimitJoint(body1, body2, lowerAngle, upperAngle);
                Simulator.Add(angleLimitJoint);
            }

            if (collisionGroup > 0)
            {
                geom1.CollisionGroup = collisionGroup;
                geom2.CollisionGroup = collisionGroup;
            }

            // get rid of the UI representation of the joint
            joint.VisualElement.Visibility = Visibility.Collapsed;
        }
        /// <summary>
        /// Adds a single Static holder object from a canvas into the simulation.
        /// </summary>
        /// <param name="cnvContainer">The static holder to add</param>
        public void AddStaticHolder(string body)
        {
            if (!PhysicsObjects.ContainsKey(body))
            {
                throw new Exception("A PhysicsStaticHolder exists with an invalid Body value of '" + body + "'.");
            }

            Body body1 = PhysicsObjects[body].BodyObject;

            body1.IsStatic = true;
        }
        /// <summary>
        /// Adds a single Static holder object from a canvas into the simulation.
        /// </summary>
        /// <param name="cnvContainer">The static holder to add</param>
        public void AddStaticHolder(PhysicsStaticHolder staticHolder)
        {
            if (!PhysicsObjects.ContainsKey(staticHolder.Body))
            {
                throw new Exception("A PhysicsStaticHolder exists with an invalid Body value of '" + staticHolder.Body + "'.");
            }

            Body body1 = PhysicsObjects[staticHolder.Body].BodyObject;

            body1.IsStatic = true;

            staticHolder.Visibility = Visibility.Collapsed;
        }
        /// <summary>
        /// Adds a single joint objectt from a Canvas into the simulation.
        /// </summary>
        /// <param name="cnvContainer">The Canvas to add joints from</param>
        public void AddJoint(PhysicsJoint joint)
        {
            if (!PhysicsObjects.ContainsKey(joint.BodyOne))
            {
                throw new Exception("A PhysicsJoint exists with an invalid BodyOne value of '" + joint.BodyOne + "'.");
            }
            if (!PhysicsObjects.ContainsKey(joint.BodyTwo))
            {
                throw new Exception("A PhysicsJoint exists with an invalid BodyTwo value of '" + joint.BodyTwo + "'.");
            }


            Body body1 = PhysicsObjects[joint.BodyOne].BodyObject;
            Body body2 = PhysicsObjects[joint.BodyTwo].BodyObject;

            Geom geom1 = PhysicsObjects[joint.BodyOne].GeometryObject;
            Geom geom2 = PhysicsObjects[joint.BodyTwo].GeometryObject;


            Vector2 ptCollisionCenter = new Vector2((float)(joint.GetCenter().X), (float)(joint.GetCenter().Y));

            RevoluteJoint revoluteJoint = JointFactory.Instance.CreateRevoluteJoint(Simulator, body1, body2, ptCollisionCenter);

            joint.RevoluteJointObject = revoluteJoint;

            if (joint.AngleSpringEnabled)
            {
                float       springConstant    = joint.AngleSpringConstant;
                float       dampeningConstant = joint.AngleSpringDampningConstant;
                AngleSpring angleSpring       = new AngleSpring(body1, body2, springConstant, dampeningConstant);
                Simulator.Add(angleSpring);
            }

            if (joint.CollisionGroup > 0)
            {
                geom1.CollisionGroup = joint.CollisionGroup;
                geom2.CollisionGroup = joint.CollisionGroup;
            }

            joint.Visibility = Visibility.Collapsed;
        }