DestructibleActorJoint.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) 2018 NVIDIA Corporation. All rights reserved.



#ifndef DESTRUCTIBLE_ACTOR_JOINT_H
#define DESTRUCTIBLE_ACTOR_JOINT_H

#include "ModuleDestructible.h"

#include "extensions/PxJoint.h"


namespace nvidia
{
namespace apex
{

PX_PUSH_PACK_DEFAULT

class DestructibleActorJointDesc : public ApexDesc
{
public:

    PX_INLINE               DestructibleActorJointDesc();

    PX_INLINE void          setToDefault();

    PX_INLINE bool          isValid() const;

    physx::PxJointConcreteType::Enum type;
    PxRigidActor*           actor[2];
    PxVec3                  localAxis[2];
    PxVec3                  localAnchor[2];
    PxVec3                  localNormal[2];

    DestructibleActor*      destructible[2];

    int32_t                 attachmentChunkIndex[2];


    PxVec3          globalAnchor[2];

    PxVec3          globalAxis[2];

    PxVec3          globalNormal[2];
};

// DestructibleActorJointDesc inline functions

PX_INLINE DestructibleActorJointDesc::DestructibleActorJointDesc() : ApexDesc()
{
    setToDefault();
}

PX_INLINE void DestructibleActorJointDesc::setToDefault()
{
    ApexDesc::setToDefault();
    for (int i=0; i<2; i++)
    {
        actor[i] = 0;
        localAxis[i]    = PxVec3(0,0,1);
        localNormal[i]  = PxVec3(1,0,0);
        localAnchor[i]  = PxVec3(0);
    }
    for (int i = 0; i < 2; ++i)
    {
        destructible[i] = NULL;
        attachmentChunkIndex[i] = ModuleDestructibleConst::INVALID_CHUNK_INDEX;
        globalAnchor[i] = PxVec3(0.0f);
        globalAxis[i] = PxVec3(0.0f, 0.0f, 1.0f);
        globalNormal[i] = PxVec3(1.0f, 0.0f, 0.0f);
    }
}

PX_INLINE bool DestructibleActorJointDesc::isValid() const
{
    if (destructible[0] == NULL && destructible[1] == NULL)
    {
        return false;
    }

    for (int i = 0; i < 2; ++i)
    {
        if (PxAbs(globalAxis[i].magnitudeSquared() - 1.0f) > 0.1f)
        {
            return false;
        }
        if (PxAbs(globalNormal[i].magnitudeSquared() - 1.0f) > 0.1f)
        {
            return false;
        }
        //check orthogonal pairs
        if (PxAbs(globalAxis[i].dot(globalNormal[i])) > 0.1f)
        {
            return false;
        }
    }

    return ApexDesc::isValid();
}


class DestructibleActorJoint : public ApexInterface
{
public:
    virtual PxJoint*    joint() = 0;

protected:
    virtual             ~DestructibleActorJoint() {}
};

PX_POP_PACK

}
} // end namespace nvidia

#endif // DESTRUCTIBLE_ACTOR_JOINT_H