JointData.h

Go to the documentation of this file.

/*************************************************************************
*                                                                       *
* Open Physics Abstraction Layer                                        *
* Copyright (C) 2004-2005                                               *
* Alan Fischer  alan.fischer@gmail.com                                  *
* Andres Reinot  andres@reinot.com                                      *
* Tyler Streeter  tylerstreeter@gmail.com                               *
* All rights reserved.                                                  *
* Web: opal.sourceforge.net                                             *
*                                                                       *
* This library is free software; you can redistribute it and/or         *
* modify it under the terms of EITHER:                                  *
*   (1) The GNU Lesser General Public License as published by the Free  *
*       Software Foundation; either version 2.1 of the License, or (at  *
*       your option) any later version. The text of the GNU Lesser      *
*       General Public License is included with this library in the     *
*       file license-LGPL.txt.                                          *
*   (2) The BSD-style license that is included with this library in     *
*       the file license-BSD.txt.                                       *
*                                                                       *
* This library 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 files    *
* license-LGPL.txt and license-BSD.txt for more details.                *
*                                                                       *
*************************************************************************/

#ifndef OPAL_JOINT_DATA_H
#define OPAL_JOINT_DATA_H

#include "Defines.h"

namespace opal
{
    struct JointLimits
    {
        JointLimits()
        {
            low = defaults::joint::lowLimit;
            high = defaults::joint::highLimit;
            hardness = defaults::joint::limitHardness;
            bounciness = defaults::joint::limitBounciness;
        }

        real low;

        real high;

        real hardness;

        real bounciness;
    };

    struct JointAxis
    {
        JointAxis()
        {
            direction = defaults::joint::axis0Direction;
            // "limits" is initialized in its own constructor.
            limitsEnabled = defaults::joint::limitsEnabled;
        }

        Vec3r direction;

        bool limitsEnabled;

        JointLimits limits;
    };

    class JointData
    {
        public:
            OPAL_DECL JointData()
            {
                mType = defaults::joint::type;
                enabled = defaults::joint::enabled;
                name = "";
                solid0 = NULL;
                solid1 = NULL;
                internal_solid0Index = 0;
                internal_solid1Index = 0;
                solid0BlueprintRefName = "";
                solid1BlueprintRefName = "";
                anchor = defaults::joint::anchor;
                axis[ 0 ].direction = defaults::joint::axis0Direction;
                axis[ 1 ].direction = defaults::joint::axis1Direction;
                axis[ 2 ].direction = defaults::joint::axis2Direction;
                // The rest of the data from the axes are initialized in the
                // JointAxis constructor.
                breakMode = defaults::joint::breakMode;
                breakThresh = defaults::joint::breakThresh;
                accumThresh = defaults::joint::accumThresh;
                accumDamage = 0;
                contactsEnabled = defaults::joint::contactsEnabled;
                isBroken = false;
            }

            OPAL_DECL JointData( const JointData& data )
            {
                ( *this ) = data;
            }

            OPAL_DECL virtual ~JointData()
            {}

            OPAL_DECL void operator=( const JointData& data )
            {
                mType = data.mType;
                enabled = data.enabled;
                name = data.name;
                solid0 = data.solid0;
                solid1 = data.solid1;
                internal_solid0Index = data.internal_solid0Index;
                internal_solid1Index = data.internal_solid1Index;
                solid0BlueprintRefName = data.solid0BlueprintRefName;
                solid1BlueprintRefName = data.solid1BlueprintRefName;
                anchor = data.anchor;

                for ( int i = 0; i < 3; ++i )
                {
                    axis[ i ] = data.axis[ i ];
                }

                breakMode = data.breakMode;
                breakThresh = data.breakThresh;
                accumThresh = data.accumThresh;
                accumDamage = data.accumDamage;
                contactsEnabled = data.contactsEnabled;
                isBroken = data.isBroken;
            }

            OPAL_DECL virtual void OPAL_CALL setType( JointType type )
            {
                mType = type;
            }

            OPAL_DECL virtual JointType OPAL_CALL getType() const
            {
                return mType;
            }

            bool enabled;

            std::string name;

            Solid* solid0;

            Solid* solid1;

            int internal_solid0Index;

            int internal_solid1Index;

            std::string solid0BlueprintRefName;

            std::string solid1BlueprintRefName;

            Point3r anchor;

            JointAxis axis[ 3 ];

            JointBreakMode breakMode;

            real breakThresh;

            real accumThresh;

            real accumDamage;

            bool contactsEnabled;


            bool isBroken;

        protected:
            JointType mType;

        private:
    };
}

#endif

---