CollideSoftBodyVertexIterator.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/SoftBody/SoftBodyVertex.h>
#include <Jolt/Core/StridedPtr.h>
 
JPH_NAMESPACE_BEGIN
 
class CollideSoftBodyVertexIterator
{
public:
                                    CollideSoftBodyVertexIterator() = default;
                                    CollideSoftBodyVertexIterator(const CollideSoftBodyVertexIterator &) = default;
 
                                    CollideSoftBodyVertexIterator(const StridedPtr<const Vec3> &inPosition, const StridedPtr<const float> &inInvMass, const StridedPtr<Plane> &inCollisionPlane, const StridedPtr<float> &inLargestPenetration, const StridedPtr<int> &inCollidingShapeIndex) :
        mPosition(inPosition),
        mInvMass(inInvMass),
        mCollisionPlane(inCollisionPlane),
        mLargestPenetration(inLargestPenetration),
        mCollidingShapeIndex(inCollidingShapeIndex)
    {
    }
 
    explicit                        CollideSoftBodyVertexIterator(SoftBodyVertex *inVertices) :
        mPosition(&inVertices->mPosition, sizeof(SoftBodyVertex)),
        mInvMass(&inVertices->mInvMass, sizeof(SoftBodyVertex)),
        mCollisionPlane(&inVertices->mCollisionPlane, sizeof(SoftBodyVertex)),
        mLargestPenetration(&inVertices->mLargestPenetration, sizeof(SoftBodyVertex)),
        mCollidingShapeIndex(&inVertices->mCollidingShapeIndex, sizeof(SoftBodyVertex))
    {
    }
 
    CollideSoftBodyVertexIterator & operator = (const CollideSoftBodyVertexIterator &) = default;
 
    bool                            operator != (const CollideSoftBodyVertexIterator &inRHS) const
    {
        return mPosition != inRHS.mPosition;
    }
 
    CollideSoftBodyVertexIterator & operator ++ ()
    {
        ++mPosition;
        ++mInvMass;
        ++mCollisionPlane;
        ++mLargestPenetration;
        ++mCollidingShapeIndex;
        return *this;
    }
 
    CollideSoftBodyVertexIterator   operator + (int inOffset) const
    {
        return CollideSoftBodyVertexIterator(mPosition + inOffset, StridedPtr<const float>(), StridedPtr<Plane>(), StridedPtr<float>(), StridedPtr<int>());
    }
 
    Vec3                            GetPosition() const
    {
        return *mPosition;
    }
 
    float                           GetInvMass() const
    {
        return *mInvMass;
    }
 
    bool                            UpdatePenetration(float inLargestPenetration) const
    {
        float &penetration = *mLargestPenetration;
        if (penetration >= inLargestPenetration)
            return false;
        penetration = inLargestPenetration;
        return true;
    }
 
    void                            SetCollision(const Plane &inCollisionPlane, int inCollidingShapeIndex) const
    {
        *mCollisionPlane = inCollisionPlane;
        *mCollidingShapeIndex = inCollidingShapeIndex;
    }
 
private:
    StridedPtr<const Vec3>          mPosition;
    StridedPtr<const float>         mInvMass;
 
    StridedPtr<Plane>               mCollisionPlane;
    StridedPtr<float>               mLargestPenetration;
    StridedPtr<int>                 mCollidingShapeIndex;
};
 
JPH_NAMESPACE_END