Program Listing for include/vehicle2/drivetrain/PxVehicleDrivetrainStates.h

↰ Return to documentation for include/vehicle2/drivetrain/PxVehicleDrivetrainStates.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.

#pragma once

#include "vehicle2/commands/PxVehicleCommandStates.h"

#if !PX_DOXYGEN
namespace physx
{
namespace vehicle2
{
#endif


struct PxVehicleClutchCommandResponseState
{
    PxReal normalisedCommandResponse;
    PxReal commandResponse;

    PX_FORCE_INLINE void setToDefault()
    {
        PxMemZero(this, sizeof(PxVehicleClutchCommandResponseState));
    }
};

struct PxVehicleEngineDriveThrottleCommandResponseState
{
    PxReal commandResponse;

    PX_FORCE_INLINE void setToDefault()
    {
        PxMemZero(this, sizeof(PxVehicleEngineDriveThrottleCommandResponseState));
    }
};

struct PxVehicleEngineState
{
    PxReal rotationSpeed;

    PX_FORCE_INLINE void setToDefault()
    {
        PxMemZero(this, sizeof(PxVehicleEngineState));
    }
};

#define PX_VEHICLE_NO_GEAR_SWITCH_PENDING -1.0f
#define PX_VEHICLE_GEAR_SWITCH_INITIATED -2.0f

struct PxVehicleGearboxState
{
    PxU32 currentGear;

    PxU32 targetGear;

    PxReal gearSwitchTime;

    PX_FORCE_INLINE void setToDefault()
    {
        currentGear = 0;
        targetGear = 0;
        gearSwitchTime = PX_VEHICLE_NO_GEAR_SWITCH_PENDING;
    }
};

#define PX_VEHICLE_UNSPECIFIED_TIME_SINCE_LAST_SHIFT PX_MAX_F32

struct PxVehicleAutoboxState
{
    PxReal timeSinceLastShift;

    bool activeAutoboxGearShift;

    PX_FORCE_INLINE void setToDefault()
    {
        timeSinceLastShift = PX_VEHICLE_UNSPECIFIED_TIME_SINCE_LAST_SHIFT;
        activeAutoboxGearShift = false;
    }
};

struct PxVehicleDifferentialState
{
    PxU32 connectedWheels[PxVehicleLimits::eMAX_NB_WHEELS];

    PxU32 nbConnectedWheels;

    PxReal torqueRatiosAllWheels[PxVehicleLimits::eMAX_NB_WHEELS];

    PxReal aveWheelSpeedContributionAllWheels[PxVehicleLimits::eMAX_NB_WHEELS];

    PX_FORCE_INLINE void setToDefault()
    {
        PxMemZero(this, sizeof(PxVehicleDifferentialState));
    }
};

struct PxVehicleWheelConstraintGroupState
{
    PX_FORCE_INLINE void setToDefault()
    {
        PxMemZero(this, sizeof(PxVehicleWheelConstraintGroupState));
    }

    void addConstraintGroup(const PxU32 nbWheelsInGroupToAdd, const PxU32* const wheelIdsInGroupToAdd, const PxF32* constraintMultipliers)
    {
        PX_ASSERT((nbWheelsInGroups + nbWheelsInGroupToAdd) < PxVehicleLimits::eMAX_NB_WHEELS);
        PX_ASSERT(nbGroups < PxVehicleLimits::eMAX_NB_WHEELS);
        nbWheelsPerGroup[nbGroups] = nbWheelsInGroupToAdd;
        groupToWheelIds[nbGroups] = nbWheelsInGroups;
        for (PxU32 i = 0; i < nbWheelsInGroupToAdd; i++)
        {
            wheelIdsInGroupOrder[nbWheelsInGroups + i] = wheelIdsInGroupToAdd[i];
            wheelMultipliersInGroupOrder[nbWheelsInGroups + i] = constraintMultipliers[i];
        }
        nbWheelsInGroups += nbWheelsInGroupToAdd;
        nbGroups++;
    }

    PX_FORCE_INLINE PxU32 getNbConstraintGroups() const
    {
        return nbGroups;
    }

    PX_FORCE_INLINE PxU32 getNbWheelsInConstraintGroup(const PxU32 i) const
    {
        return nbWheelsPerGroup[i];
    }

    PX_FORCE_INLINE PxU32 getWheelInConstraintGroup(const PxU32 j, const PxU32 i) const
    {
        return wheelIdsInGroupOrder[groupToWheelIds[i] + j];
    }

    PX_FORCE_INLINE PxReal getMultiplierInConstraintGroup(const PxU32 j, const PxU32 i) const
    {
        return wheelMultipliersInGroupOrder[groupToWheelIds[i] + j];
    }

    PxU32 nbGroups;
    PxU32 nbWheelsPerGroup[PxVehicleLimits::eMAX_NB_AXLES];
    PxU32 groupToWheelIds[PxVehicleLimits::eMAX_NB_AXLES];

    PxU32 wheelIdsInGroupOrder[PxVehicleLimits::eMAX_NB_WHEELS];
    PxF32 wheelMultipliersInGroupOrder[PxVehicleLimits::eMAX_NB_WHEELS];
    PxU32 nbWheelsInGroups;
};

struct PxVehicleClutchSlipState
{
    PxReal clutchSlip;

    PX_FORCE_INLINE void setToDefault()
    {
        PxMemZero(this, sizeof(PxVehicleClutchSlipState));
    }
};




#if !PX_DOXYGEN
} // namespace vehicle2
} // namespace physx
#endif