tgRigidInfo.h

Go to the documentation of this file.

/*
 * Copyright © 2012, United States Government, as represented by the
 * Administrator of the National Aeronautics and Space Administration.
 * All rights reserved.
 * 
 * The NASA Tensegrity Robotics Toolkit (NTRT) v1 platform is licensed
 * under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0.
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
*/

#ifndef TG_RIGID_INFO_H
#define TG_RIGID_INFO_H

// The C++ Standard Library
#include <set>
// This library
#include "core/tgTaggable.h"
#include "core/tgModel.h"
//Bullet Physics
#include "LinearMath/btVector3.h"
#include "LinearMath/btQuaternion.h"

// Forward references
class tgCompoundRigidInfo;
class tgNode;
class tgNodes;
class tgPair;
class tgPairs;
class tgTagSearch;
class tgWorld;

class btCollisionObject;
class btRigidBody;
class btCollisionShape;
class btTransform;

class tgRigidInfo : public tgTaggable {
public:
        
    tgRigidInfo() : 
        tgTaggable(),
        m_collisionShape(NULL), 
        m_rigidInfoGroup(NULL), 
        m_collisionObject(NULL)
    {}    

    tgRigidInfo(tgTags tags) : 
        tgTaggable(tags),
        m_collisionShape(NULL), 
        m_rigidInfoGroup(NULL), 
        m_collisionObject(NULL)
    {}    

    tgRigidInfo(const std::string& space_separated_tags) :
        tgTaggable(space_separated_tags),
        m_collisionShape(NULL), 
        m_rigidInfoGroup(NULL), 
        m_collisionObject(NULL)        
    {}    
    
    virtual ~tgRigidInfo() 
    {
    }
    
    // To be overridden by subclasses
    virtual tgRigidInfo* createRigidInfo(const tgNode& node)
    {
        return 0;
    }

    virtual tgRigidInfo* createRigidInfo(const tgPair& pair)
    {
        return 0;
    }

    virtual tgRigidInfo* createRigidInfo(const tgNode& node, const tgTagSearch& tagSearch);

    virtual tgRigidInfo* createRigidInfo(const tgPair& pair, const tgTagSearch& tagSearch);

    virtual std::vector<tgRigidInfo*> createRigidInfos(const tgNodes& nodes, const tgTagSearch& tagSearch);

    virtual std::vector<tgRigidInfo*> createRigidInfos(const tgPairs& pairs, const tgTagSearch& tagSearch);

    virtual void initRigidBody(tgWorld& world);

    virtual tgModel* createModel(tgWorld& world) = 0;

    virtual btCollisionShape* getCollisionShape(tgWorld& world) const = 0;

    void setCollisionShape(btCollisionShape* p_btCollisionShape)
    {
        m_collisionShape = p_btCollisionShape;
    }

    virtual tgRigidInfo* getRigidInfoGroup()
    {
        return m_rigidInfoGroup;
    }

    virtual const tgRigidInfo* getRigidInfoGroup() const
    {
        return m_rigidInfoGroup;
    }

    virtual void setRigidInfoGroup(tgRigidInfo* rigidInfoGroup)
    {
        m_rigidInfoGroup = rigidInfoGroup;
    }

    virtual btRigidBody* getRigidBody();

    virtual const btRigidBody* getRigidBody() const;
    
    virtual void setRigidBody(btRigidBody* rigidBody);
    
    virtual btCollisionObject* getCollisionObject()
    {
                                return m_collisionObject;
                }
                
    virtual const btCollisionObject* getCollisionObject() const
    {
                                return m_collisionObject;
                }
                
    virtual void setCollisionObject(btCollisionObject* collisionObject)
    {
                                m_collisionObject = collisionObject;
                }
        
    virtual btTransform getTransform() const = 0;
    
    virtual double getMass() const = 0;
    
    virtual btVector3 getCenterOfMass() const = 0;

    virtual btVector3 
    getConnectionPoint(const btVector3& referencePoint,
               const btVector3& destinationPoint) const = 0;
    
    virtual btVector3 
    getConnectionPoint(const btVector3& referencePoint,
               const btVector3& destinationPoint,
               const double rotation) const
   {
       return getConnectionPoint(referencePoint, destinationPoint);
   }

    bool isCompound() const { return getCompound() != 0; }
        
    virtual tgCompoundRigidInfo* getCompound() = 0;
        
    virtual const tgCompoundRigidInfo* getCompound() const = 0;

    virtual std::set<tgRigidInfo*> getLeafRigids() = 0;

    virtual bool containsNode(const btVector3& nodeVector) const = 0;

    virtual std::set<btVector3> getContainedNodes() const = 0;

    virtual bool sharesNodesWith(const tgRigidInfo& other) const;
   
    // Need these in order to see if we've already build a pair/node
    // @todo: maybe -- don't like having to know about pairs and nodes here...
    // virtual bool matches(const tgPair& pair) = 0;
    // virtual bool matches(const tgNode& node) = 0;

protected:  // Protected, not private -- subclasses need access
    
    mutable btCollisionShape* m_collisionShape;

    mutable tgRigidInfo* m_rigidInfoGroup;

    mutable btCollisionObject* m_collisionObject;
    
};


inline std::ostream&
operator<<(std::ostream& os, const tgRigidInfo& obj)
{
    os << "tgRigidInfo(" << obj.getRigidInfoGroup() << ", " << obj.getRigidBody() << ")";
    return os;
}


#endif