PxArticulationTendon.h

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2022 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
 
 
#ifndef PX_ARTICULATION_TENDON_H
#define PX_ARTICULATION_TENDON_H
#include "PxPhysXConfig.h"
#include "common/PxBase.h"
#include "solver/PxSolverDefs.h"
 
#if !PX_DOXYGEN
namespace physx
{
#endif
    class PxArticulationSpatialTendon;
    class PxArticulationFixedTendon;
    class PxArticulationLink;
    class PxArticulationTendonLimit
    {
    public:
        PxReal lowLimit;
        PxReal highLimit;
    };
 
    class PxArticulationAttachment : public PxBase
    {
 
    public:
 
        virtual ~PxArticulationAttachment() {}
        virtual     void                            setRestLength(const PxReal restLength) = 0;
 
        virtual     PxReal                          getRestLength() const = 0;
 
        virtual     void                            setLimitParameters(const PxArticulationTendonLimit& parameters) = 0;
 
        virtual     PxArticulationTendonLimit       getLimitParameters() const = 0;
 
        virtual     void                            setRelativeOffset(const PxVec3& offset) = 0;
 
        virtual     PxVec3                          getRelativeOffset() const = 0;
 
        virtual     void                            setCoefficient(const PxReal coefficient) = 0;
 
        virtual     PxReal                          getCoefficient() const = 0;
 
        virtual     PxArticulationLink*             getLink() const = 0;
 
        virtual     PxArticulationAttachment*       getParent() const = 0;
 
        virtual     bool                            isLeaf() const = 0;
 
        virtual     PxArticulationSpatialTendon*    getTendon() const = 0;
 
        virtual     void                            release() = 0;
 
                    void*                           userData;   
 
        virtual const char*                     getConcreteTypeName() const { return "PxArticulationAttachment"; }
 
    protected:
 
        PX_INLINE   PxArticulationAttachment(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
        PX_INLINE   PxArticulationAttachment(PxBaseFlags baseFlags) : PxBase(baseFlags) {}
    };
 
 
    class PxArticulationTendonJoint : public PxBase
    {
 
    public:
 
        virtual ~PxArticulationTendonJoint() {}
 
        virtual     void                            setCoefficient(const PxArticulationAxis::Enum axis, const PxReal coefficient, const PxReal recipCoefficient) = 0;
 
        virtual     void                            getCoefficient(PxArticulationAxis::Enum& axis, PxReal& coefficient, PxReal& recipCoefficient) const = 0;
 
        virtual     PxArticulationLink*             getLink() const = 0;
 
        virtual     PxArticulationTendonJoint*      getParent() const = 0;
 
        virtual     PxArticulationFixedTendon*      getTendon() const = 0;
 
        virtual     void                            release() = 0;
 
                    void*                           userData;   
 
        virtual const char*                         getConcreteTypeName() const { return "PxArticulationTendonJoint"; }
 
    protected:
 
        PX_INLINE   PxArticulationTendonJoint(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
        PX_INLINE   PxArticulationTendonJoint(PxBaseFlags baseFlags) : PxBase(baseFlags) {}
    };
 
 
    class PxArticulationTendon : public PxBase
    {
    public:
        virtual     void                            setStiffness(const PxReal stiffness) = 0;
 
        virtual     PxReal                          getStiffness() const = 0;
 
        virtual     void                            setDamping(const PxReal damping) = 0;
 
        virtual     PxReal                          getDamping() const = 0;
 
        virtual     void                            setLimitStiffness(const PxReal stiffness) = 0;
 
        virtual     PxReal                          getLimitStiffness() const = 0;
 
        virtual     void                            setOffset(const PxReal offset, bool autowake = true) = 0;
 
        virtual     PxReal                          getOffset() const = 0;
 
        virtual     PxArticulationReducedCoordinate* getArticulation() const = 0;
 
        virtual     void                            release() = 0;
 
        virtual                                     ~PxArticulationTendon() {}
 
                    void*                           userData;   
 
    protected:
        PX_INLINE   PxArticulationTendon(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
        PX_INLINE   PxArticulationTendon(PxBaseFlags baseFlags) : PxBase(baseFlags) {}
    };
 
    class PxArticulationSpatialTendon : public PxArticulationTendon
    {
    public:
        virtual     PxArticulationAttachment*       createAttachment(PxArticulationAttachment* parent, const PxReal coefficient, const PxVec3 relativeOffset, PxArticulationLink* link) = 0;
 
        virtual     PxU32                           getAttachments(PxArticulationAttachment** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const = 0;
 
        virtual     PxU32                           getNbAttachments() const = 0;
 
        virtual const char*                     getConcreteTypeName() const { return "PxArticulationSpatialTendon"; }
 
        virtual                                 ~PxArticulationSpatialTendon() {}
 
    protected:
        PX_INLINE   PxArticulationSpatialTendon(PxType concreteType, PxBaseFlags baseFlags) : PxArticulationTendon(concreteType, baseFlags) {}
        PX_INLINE   PxArticulationSpatialTendon(PxBaseFlags baseFlags) : PxArticulationTendon(baseFlags) {}
 
    };
 
    class PxArticulationFixedTendon : public PxArticulationTendon
    {
    public:
        virtual     PxArticulationTendonJoint*      createTendonJoint(PxArticulationTendonJoint* parent, PxArticulationAxis::Enum axis, const PxReal coefficient, const PxReal recipCoefficient, PxArticulationLink* link) = 0;
 
        virtual     PxU32                           getTendonJoints(PxArticulationTendonJoint** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const = 0;
 
        virtual     PxU32                           getNbTendonJoints() const = 0;
 
        virtual     void                            setRestLength(const PxReal restLength) = 0;
 
        virtual     PxReal                          getRestLength() const = 0;
 
        virtual     void                            setLimitParameters(const PxArticulationTendonLimit& parameter) = 0;
 
 
        virtual     PxArticulationTendonLimit       getLimitParameters() const = 0;
 
        virtual const char*                     getConcreteTypeName() const { return "PxArticulationFixedTendon"; }
 
        virtual                                 ~PxArticulationFixedTendon() {}
 
    protected:
        PX_INLINE   PxArticulationFixedTendon(PxType concreteType, PxBaseFlags baseFlags) : PxArticulationTendon(concreteType, baseFlags) {}
        PX_INLINE   PxArticulationFixedTendon(PxBaseFlags baseFlags) : PxArticulationTendon(baseFlags) {}
    };
 
#if !PX_DOXYGEN
} // namespace physx
#endif
 
#endif