示例#1
0
        //--------------- Internals Below -------------------

        /** @private */
        public b2PulleyJoint(b2PulleyJointDef def) : base(def)
        {
            b2Mat22 tMat;
            float   tX;
            float   tY;

            m_ground = m_bodyA.m_world.m_groundBody;
            //m_groundAnchor1 = def->groundAnchorA - m_ground->m_xf.position;
            m_groundAnchor1.x = def.groundAnchorA.x - m_ground.m_xf.position.x;
            m_groundAnchor1.y = def.groundAnchorA.y - m_ground.m_xf.position.y;
            //m_groundAnchor2 = def->groundAnchorB - m_ground->m_xf.position;
            m_groundAnchor2.x = def.groundAnchorB.x - m_ground.m_xf.position.x;
            m_groundAnchor2.y = def.groundAnchorB.y - m_ground.m_xf.position.y;
            //m_localAnchor1 = def->localAnchorA;
            m_localAnchor1.SetV(def.localAnchorA);
            //m_localAnchor2 = def->localAnchorB;
            m_localAnchor2.SetV(def.localAnchorB);

            //b2Settings.b2Assert(def.ratio != 0.0);
            m_ratio = def.ratio;

            m_constant = def.lengthA + m_ratio * def.lengthB;

            m_maxLength1 = b2Math.Min(def.maxLengthA, m_constant - m_ratio * b2_minPulleyLength);
            m_maxLength2 = b2Math.Min(def.maxLengthB, (m_constant - b2_minPulleyLength) / m_ratio);

            m_impulse       = 0.0f;
            m_limitImpulse1 = 0.0f;
            m_limitImpulse2 = 0.0f;
        }
示例#2
0
        public Pulleys()
        {
            float y = 16.0f;
            float L = 12.0f;
            float a = 1.0f;
            float b = 2.0f;

            b2Body ground = null;
            {
                b2BodyDef bd  = new b2BodyDef();
                ground = m_world.CreateBody(bd);

                b2EdgeShape edge = new b2EdgeShape();
                edge.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f));
                //ground->CreateFixture(&shape, 0.0f);

                b2CircleShape circle = new b2CircleShape();
                circle.Radius = 2.0f;

                circle.Position = new b2Vec2(-10.0f, y + b + L);
                ground.CreateFixture(circle, 0.0f);

                circle.Position = new b2Vec2(10.0f, y + b + L);
                ground.CreateFixture(circle, 0.0f);
            }

            {

                b2PolygonShape shape = new b2PolygonShape();
                shape.SetAsBox(a, b);

                b2BodyDef bd  = new b2BodyDef();
                bd.type = b2BodyType.b2_dynamicBody;

                //bd.fixedRotation = true;
                bd.position.Set(-10.0f, y);
                b2Body body1 = m_world.CreateBody(bd);
                body1.CreateFixture(shape, 5.0f);

                bd.position.Set(10.0f, y);
                b2Body body2 = m_world.CreateBody(bd);
                body2.CreateFixture(shape, 5.0f);

                b2PulleyJointDef pulleyDef = new b2PulleyJointDef();
                b2Vec2 anchor1 = new b2Vec2(-10.0f, y + b);
                b2Vec2 anchor2 = new b2Vec2(10.0f, y + b);
                b2Vec2 groundAnchor1 = new b2Vec2(-10.0f, y + b + L);
                b2Vec2 groundAnchor2 = new b2Vec2(10.0f, y + b + L);
                pulleyDef.Initialize(body1, body2, groundAnchor1, groundAnchor2, anchor1, anchor2, 1.5f);

                m_joint1 = (b2PulleyJoint) m_world.CreateJoint(pulleyDef);
            }
        }
示例#3
0
        public b2PulleyJoint(b2PulleyJointDef def)
            : base(def)
        {
            m_groundAnchorA = def.groundAnchorA;
            m_groundAnchorB = def.groundAnchorB;
            m_localAnchorA = def.localAnchorA;
            m_localAnchorB = def.localAnchorB;

            m_lengthA = def.lengthA;
            m_lengthB = def.lengthB;

            Debug.Assert(def.ratio != 0.0f);
            m_ratio = def.ratio;

            m_constant = def.lengthA + m_ratio * def.lengthB;

            m_impulse = 0.0f;
        }
示例#4
0
        public b2PulleyJoint(b2PulleyJointDef def)
            : base(def)
        {
            m_groundAnchorA = def.groundAnchorA;
            m_groundAnchorB = def.groundAnchorB;
            m_localAnchorA  = def.localAnchorA;
            m_localAnchorB  = def.localAnchorB;

            m_lengthA = def.lengthA;
            m_lengthB = def.lengthB;

            Debug.Assert(def.ratio != 0.0f);
            m_ratio = def.ratio;

            m_constant = def.lengthA + m_ratio * def.lengthB;

            m_impulse = 0.0f;
        }
示例#5
0
        // SIN REVISAR
        b2Joint j2b2Joint(b2World world, JObject jointValue)
        {
            b2Joint joint = null;

            int bodyIndexA = (int)jointValue["bodyA"];
            int bodyIndexB = (int)jointValue["bodyB"];
            if (bodyIndexA >= m_bodies.Count || bodyIndexB >= m_bodies.Count)
                return null;

            // set features common to all joints
            //var bodyA = m_bodies[bodyIndexA];
            //var bodyB = m_bodies[bodyIndexB];
            //var collideConnected = jointValue["collideConnected"] == null ? false : (bool)jointValue["collideConnected"];

            // keep these in scope after the if/else below
            b2RevoluteJointDef revoluteDef;
            b2PrismaticJointDef prismaticDef;
            b2DistanceJointDef distanceDef;
            b2PulleyJointDef pulleyDef;
            b2MouseJointDef mouseDef;
            b2GearJointDef gearDef;
            //b2WheelJoint wheelDef;
            b2WeldJointDef weldDef;
            b2FrictionJointDef frictionDef;
            b2RopeJointDef ropeDef;
            //MotorJoint motorDef;

            b2JointDef jointDef = null;

            b2Vec2 mouseJointTarget = new b2Vec2(0, 0);

            string type = jointValue["type"].ToString() == null ? "" : jointValue["type"].ToString();

            if (type == "revolute")
            {

                jointDef = revoluteDef = new b2RevoluteJointDef(); // JointFactory.CreateRevoluteJoint(world, bodyA, bodyB, jsonToVec("anchorB", jointValue));
                revoluteDef.localAnchorA = jsonToVec("anchorA", jointValue);
                revoluteDef.localAnchorB = jsonToVec("anchorB", jointValue);
                revoluteDef.referenceAngle = jsonToFloat("refAngle", jointValue);
                revoluteDef.enableLimit = jointValue["enableLimit"] == null ? false : (bool)jointValue["enableLimit"];
                revoluteDef.lowerAngle = jsonToFloat("lowerLimit", jointValue);
                revoluteDef.upperAngle = jsonToFloat("upperLimit", jointValue);
                revoluteDef.enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];
                revoluteDef.motorSpeed = jsonToFloat("motorSpeed", jointValue);
                revoluteDef.maxMotorTorque = jsonToFloat("maxMotorTorque", jointValue);
            }
            else if (type == "prismatic")
            {
                jointDef = prismaticDef = new b2PrismaticJointDef(); //JointFactory.CreatePrismaticJoint(world, bodyA, bodyB, localAnchorB, localAxis);

                prismaticDef.localAnchorA = jsonToVec("anchorA", jointValue);
                prismaticDef.localAnchorB = jsonToVec("anchorB", jointValue);

                if (jointValue["localAxisA"] != null)
                    prismaticDef.localAxisA = jsonToVec("localAxisA", jointValue);
                else
                    prismaticDef.localAxisA = jsonToVec("localAxis1", jointValue);

                prismaticDef.referenceAngle = jsonToFloat("refAngle", jointValue);

                prismaticDef.enableLimit = jointValue["enableLimit"] == null ? false : (bool)jointValue["enableLimit"];

                prismaticDef.lowerTranslation = jsonToFloat("lowerLimit", jointValue);
                prismaticDef.upperTranslation = jsonToFloat("upperLimit", jointValue);

                prismaticDef.enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];

                prismaticDef.motorSpeed = jsonToFloat("motorSpeed", jointValue);
                prismaticDef.maxMotorForce = jsonToFloat("maxMotorForce", jointValue);

            }
            else if (type == "distance")
            {

                jointDef = distanceDef = new b2DistanceJointDef();
                distanceDef.localAnchorA = jsonToVec("anchorA", jointValue);
                distanceDef.localAnchorB = jsonToVec("anchorB", jointValue);
                distanceDef.length = jsonToFloat("length", jointValue);
                distanceDef.frequencyHz = jsonToFloat("frequency", jointValue);
                distanceDef.dampingRatio = jsonToFloat("dampingRatio", jointValue);

            }
            else if (type == "pulley")
            {

                jointDef = pulleyDef = new b2PulleyJointDef();
                pulleyDef.groundAnchorA = jsonToVec("groundAnchorA", jointValue);
                pulleyDef.groundAnchorB = jsonToVec("groundAnchorB", jointValue);
                pulleyDef.localAnchorA = jsonToVec("anchorA", jointValue);
                pulleyDef.localAnchorB = jsonToVec("anchorB", jointValue);
                pulleyDef.lengthA = jsonToFloat("lengthA", jointValue);
                pulleyDef.lengthB = jsonToFloat("lengthB", jointValue);
                pulleyDef.ratio = jsonToFloat("ratio", jointValue);

            }
            else if (type == "mouse")
            {
                jointDef = mouseDef = new b2MouseJointDef();
                mouseJointTarget = jsonToVec("target", jointValue);
                mouseDef.target = jsonToVec("anchorB", jointValue);// alter after creating joint
                mouseDef.maxForce = jsonToFloat("maxForce", jointValue);
                mouseDef.frequencyHz = jsonToFloat("frequency", jointValue);
                mouseDef.dampingRatio = jsonToFloat("dampingRatio", jointValue);
            }
            // Gear joints are apparently not implemented in JBox2D yet, but
            // when they are, commenting out the following section should work.

            else if (type == "gear")
            {

                jointDef = gearDef = new b2GearJointDef();  //JointFactory.CreateGearJoint(world, joint1, joint2, ratio);
                int jointIndex1 = (int)jointValue["joint1"];
                int jointIndex2 = (int)jointValue["joint2"];
                var joint1 = m_joints[jointIndex1];
                var joint2 = m_joints[jointIndex2];
                var ratio = jsonToFloat("ratio", jointValue);

                //joint = gearDef = JointFactory.CreateGearJoint(world, joint1, joint2, ratio);

            }

            // Wheel joints are apparently not implemented in JBox2D yet, but
            // when they are, commenting out the following section should work.

            else if (type == "wheel")
            {

                jointDef = revoluteDef = new b2RevoluteJointDef();
                revoluteDef.localAnchorA = jsonToVec("anchorA", jointValue);
                revoluteDef.localAnchorB = jsonToVec("anchorB", jointValue);

                revoluteDef.enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];

                revoluteDef.motorSpeed = jsonToFloat("motorSpeed", jointValue);
                revoluteDef.maxMotorTorque = jsonToFloat("maxMotorTorque", jointValue);

                //jointDef = wheelDef = new b2WheelJointDef(); //JointFactory.CreateWheelJoint(world, bodyA, bodyB, localAnchorB, localAxisA);

                //var localAnchorA = jsonToVec("anchorA", jointValue);
                //var localAnchorB = (jsonToVec("anchorB", jointValue));
                //var localAxisA = (jsonToVec("localAxisA", jointValue));
                //var enableMotor = jointValue["enableMotor"] == null ? false : (bool)jointValue["enableMotor"];
                //var motorSpeed = jsonToFloat("motorSpeed", jointValue);
                //var maxMotorTorque = jsonToFloat("maxMotorTorque", jointValue);
                //var frequencyHz = jsonToFloat("springFrequency", jointValue);
                //var dampingRatio = jsonToFloat("springDampingRatio", jointValue);

                //wheelDef.LocalAnchorA = localAnchorA;
                //wheelDef.LocalAnchorB = localAnchorB;
                //wheelDef.MotorEnabled = enableMotor;
                //wheelDef.MotorSpeed = motorSpeed;
                //wheelDef.SpringFrequencyHz = frequencyHz;
                //wheelDef.MaxMotorTorque = maxMotorTorque;
                //wheelDef.SpringDampingRatio = dampingRatio;
            }
            else if (type == "weld")
            {
                jointDef = weldDef = new b2WeldJointDef();
                weldDef.localAnchorA = jsonToVec("anchorA", jointValue);
                weldDef.localAnchorB = jsonToVec("anchorB", jointValue);
                weldDef.referenceAngle = 0;

            }
            else if (type == "friction")
            {
                jointDef = frictionDef = new b2FrictionJointDef();
                frictionDef.localAnchorA = jsonToVec("anchorA", jointValue);
                frictionDef.localAnchorB = jsonToVec("anchorB", jointValue);
                frictionDef.maxForce = jsonToFloat("maxForce", jointValue);
                frictionDef.maxTorque = jsonToFloat("maxTorque", jointValue);
            }
            else if (type == "rope")
            {
                jointDef = ropeDef = new b2RopeJointDef();
                ropeDef.localAnchorA = jsonToVec("anchorA", jointValue);
                ropeDef.localAnchorB = jsonToVec("anchorB", jointValue);
                ropeDef.maxLength = jsonToFloat("maxLength", jointValue);
            }

            //else if (type == "motor")
            //{
            //    var maxForce = jsonToFloat("maxForce", jointValue);
            //    var maxMotorTorque = jsonToFloat("maxTorque", jointValue);
            //    var angularOffset = jsonToFloat("refAngle", jointValue);

            //    joint = motorDef = new MotorJoint(bodyA, bodyB);
            //    world.AddJoint(joint);
            //    motorDef.LinearOffset = jsonToVec("anchorA", jointValue);
            //    motorDef.MaxForce = maxForce;
            //    motorDef.MaxTorque = maxMotorTorque;
            //    motorDef.AngularOffset = angularOffset;
            //}

            if (null != jointDef)
            {
                // set features common to all joints
                jointDef.BodyA = m_bodies[bodyIndexA];
                jointDef.BodyB = m_bodies[bodyIndexB];

                jointDef.CollideConnected = jointValue["collideConnected"] == null ? false : (bool)jointValue["collideConnected"];

                joint = world.CreateJoint(jointDef);

                if (type.Equals("mouse"))
                    ((b2MouseJoint)joint).SetTarget(mouseJointTarget);

                String jointName = jointValue["name"] == null ? "" : (string)jointValue["name"];

                if (!jointName.Equals(""))
                {
                    SetJointName(joint, jointName);
                }
            }

            return joint;
        }