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