C:/Users/Marc/Desktop/Phystank/trunk/src/game/Physics.h

//This file is part of PhysTank.
//
//PhysTank is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//PhysTank is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with PhysTank.  If not, see <http://www.gnu.org/licenses/>.
//
// © Marc Johnson, 2009

#ifndef _PHYSICSJOINTS_
#define _PHYSICSJOINTS_

#include <iostream>
#include <string>

#include "util/Attribute.h"
#include "util/Vector2.h"

#define TO_B2VEC2(vec) b2Vec2(vec._x, vec._y)
#define TO_VECTOR2(vec) Vector2(vec.x, vec.y)

struct DistanceJoint 
{
        DistanceJoint() { }
        DistanceJoint(const Vector2& anchor1, const Vector2& anchor2)
        :_anchor1(anchor1), _anchor2(anchor2)
        {
        }

        Vector2 _anchor1;
        Vector2 _anchor2;
};

void JointFromAttribute(const Attribute * pRoot, DistanceJoint & joint);
std::ostream & operator<<(std::ostream & os, const DistanceJoint & def);
std::istream & operator>>(std::istream & is, DistanceJoint & def);

struct RevoluteJoint
{
        RevoluteJoint() 
        :_fMinAngle(0.0f), _fMaxAngle(0.0f), _fMaxMotorTorque(0.0f), _fMotorSpeed(0.0f)
        {
        }

        RevoluteJoint(const Vector2 & anchor, const float fMinAngle = 0.0f, const float fMaxAngle = 0.0f,
                const float fMaxMotorTorque = 0.0f, const float fMotorSpeed = 0.0f)
        :_anchor(anchor), _fMinAngle(fMinAngle), _fMaxAngle(fMaxAngle), _fMaxMotorTorque(fMaxMotorTorque),
        _fMotorSpeed(fMotorSpeed)
        {
        }

        Vector2 _anchor;
        float _fMinAngle;
        float _fMaxAngle;
        float _fMaxMotorTorque;
        float _fMotorSpeed;
};

void JointFromAttribute(const Attribute * pRoot, RevoluteJoint & joint);
std::ostream & operator<<(std::ostream & os, const RevoluteJoint & def);
std::istream & operator>>(std::istream & is, RevoluteJoint & def);

struct PrismaticJoint
{
        PrismaticJoint()
        :_fMinTranslation(0.0f), _fMaxTranslation(0.0f), _fMaxMotorForce(0.0f), _fMotorSpeed(0.0f)
        {
        }

        PrismaticJoint(const Vector2 & anchor, const Vector2 & axis, const float fMinTranslation = 0.0f,
                const float fMaxTranslation = 0.0f, const float fMaxMotorForce = 0.0f, const float fMotorSpeed = 0.0f)
        :_anchor(anchor), _axis(axis), _fMinTranslation(fMinTranslation), _fMaxTranslation(fMaxTranslation),
        _fMaxMotorForce(fMaxMotorForce), _fMotorSpeed(fMotorSpeed)
        {
        }

        Vector2 _anchor;
        Vector2 _axis;
        float _fMinTranslation;
        float _fMaxTranslation;
        float _fMaxMotorForce;
        float _fMotorSpeed;
};

void JointFromAttribute(const Attribute * pRoot,PrismaticJoint & joint);
std::ostream & operator<<(std::ostream & os, const PrismaticJoint & def);
std::istream & operator>>(std::istream & is, PrismaticJoint & def);

struct PulleyJoint 
{
        PulleyJoint()
        :_fRatio(0.0f), _fMaxLength1(0.0f), _fMaxLength2(0.0f)
        {
        }

        PulleyJoint(const Vector2& anchor1, const Vector2& anchor2, const Vector2& groundAnchor1,
                const Vector2& groundAnchor2, const float fRatio = 1.0f, const float fMaxLength1 = 0.0f,
                const float fMaxLength2 = 0.0f)
        :_anchor1(anchor1), _anchor2(anchor2), _groundAnchor1(groundAnchor1), _groundAnchor2(groundAnchor2),
        _fRatio(fRatio), _fMaxLength1(fMaxLength1), _fMaxLength2(fMaxLength2)
        {
        }

        Vector2 _anchor1;
        Vector2 _anchor2;
        Vector2 _groundAnchor1;
        Vector2 _groundAnchor2;
        float _fRatio;
        float _fMaxLength1;
        float _fMaxLength2;
};

void JointFromAttribute(const Attribute * pRoot, PulleyJoint & joint);
std::ostream & operator<<(std::ostream & os, const PulleyJoint & def);
std::istream & operator>>(std::istream & is, PulleyJoint & def);

struct GearJoint
{
        GearJoint()
        :_fRatio(0.0f)
        {
        }

        GearJoint(const std::string & constraint1, const std::string & constraint2, const float fRatio = 1.0f)
        :_constraint1(constraint1), _constraint2(constraint2)
        {
        }

        std::string _constraint1;
        std::string _constraint2;
        float _fRatio;
};

void JointFromAttribute(const Attribute * pRoot, GearJoint & joint);
std::ostream & operator<<(std::ostream & os, const GearJoint & def);
std::istream & operator>>(std::istream & is, GearJoint & def);

#endif

---