PxVehicleUtilTelemetry.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_VEHICLE_UTIL_TELEMETRY_H
#define PX_VEHICLE_UTIL_TELEMETRY_H
 
#include "vehicle/PxVehicleSDK.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxVec3.h"
 
#if !PX_DOXYGEN
namespace physx
{
#endif
 
#if PX_DEBUG_VEHICLE_ON
 
class PX_DEPRECATED PxVehicleGraphDesc
{
 
    friend class PxVehicleGraph;
 
    PxVehicleGraphDesc();
 
    PxReal mPosX;
 
    PxReal mPosY;
 
    PxReal mSizeX;
 
    PxReal mSizeY;
 
    PxVec3 mBackgroundColor;
 
    PxReal mAlpha;
 
private:
 
    bool isValid() const;
};
 
struct PX_DEPRECATED PxVehicleGraphChannelDesc
{
public:
 
    friend class PxVehicleGraph;
 
    PxVehicleGraphChannelDesc();
 
    PxReal mMinY;
 
    PxReal mMaxY;
 
    PxReal mMidY;
 
    PxVec3 mColorLow;
 
    PxVec3 mColorHigh;
 
    char* mTitle;
 
private:
 
    bool isValid() const;
};
 
struct PX_DEPRECATED PxVehicleWheelGraphChannel
{
    enum Enum
    {
        eJOUNCE=0,
        eSUSPFORCE,
        eTIRELOAD,
        eNORMALIZED_TIRELOAD,
        eWHEEL_OMEGA, 
        eTIRE_FRICTION,
        eTIRE_LONG_SLIP,
        eNORM_TIRE_LONG_FORCE,
        eTIRE_LAT_SLIP,
        eNORM_TIRE_LAT_FORCE,
        eNORM_TIRE_ALIGNING_MOMENT,
        eMAX_NB_WHEEL_CHANNELS
    };
};
 
struct PX_DEPRECATED PxVehicleDriveGraphChannel
{
    enum Enum
    {
        eENGINE_REVS=0,
        eENGINE_DRIVE_TORQUE,
        eCLUTCH_SLIP,
        eACCEL_CONTROL,                 //TANK_ACCEL
        eBRAKE_CONTROL,                 //TANK_BRAKE_LEFT
        eHANDBRAKE_CONTROL,             //TANK_BRAKE_RIGHT
        eSTEER_LEFT_CONTROL,            //TANK_THRUST_LEFT
        eSTEER_RIGHT_CONTROL,           //TANK_THRUST_RIGHT
        eGEAR_RATIO,
        eMAX_NB_DRIVE_CHANNELS
    };
};
 
struct PX_DEPRECATED PxVehicleGraphType
{
    enum Enum
    {
        eWHEEL=0,
        eDRIVE
    };
};
 
 
class PX_DEPRECATED PxVehicleGraph
{
public:
 
    friend class PxVehicleTelemetryData;
    friend class PxVehicleUpdate;
 
    enum
    {
        eMAX_NB_SAMPLES=256
    };
 
    enum
    {
        eMAX_NB_TITLE_CHARS=256
    };
 
    enum
    {
        eMAX_NB_CHANNELS=12
    };
 
    void setup(const PxVehicleGraphDesc& desc, const PxVehicleGraphType::Enum graphType);
 
    void clearRecordedChannelData();
 
    const PxVec3& getBackgroundColor() const {return mBackgroundColor;}
 
    PxReal getBackgroundAlpha() const {return mBackgroundAlpha;}
 
    void getBackgroundCoords(PxReal& xMin, PxReal& yMin, PxReal& xMax, PxReal& yMax) const {xMin = mBackgroundMinX;xMax = mBackgroundMaxX;yMin = mBackgroundMinY;yMax = mBackgroundMaxY;}
 
    void computeGraphChannel(const PxU32 channel, PxReal* xy, PxVec3* colors, char* title) const;
 
    PxF32 getLatestValue(const PxU32 channel) const ;
 
    void getRawData(const PxU32 channel, PxReal* values) const;
 
private:
 
    //Min and max of each sample.
    PxReal mChannelMinY[eMAX_NB_CHANNELS];
    PxReal mChannelMaxY[eMAX_NB_CHANNELS];
    //Discriminate between high and low values with different colors.
    PxReal mChannelMidY[eMAX_NB_CHANNELS];
    //Different colors for values than midY and less than midY.
    PxVec3 mChannelColorLow[eMAX_NB_CHANNELS];
    PxVec3 mChannelColorHigh[eMAX_NB_CHANNELS];
    //Title of graph
    char mChannelTitle[eMAX_NB_CHANNELS][eMAX_NB_TITLE_CHARS];
    //Graph data.
    PxReal mChannelSamples[eMAX_NB_CHANNELS][eMAX_NB_SAMPLES];
 
    //Background color,alpha,coords
    PxVec3 mBackgroundColor;
    PxReal mBackgroundAlpha;
    PxReal mBackgroundMinX;
    PxReal mBackgroundMaxX;
    PxReal mBackgroundMinY;
    PxReal mBackgroundMaxY;
 
    PxU32 mSampleTide;
 
    PxU32 mNbChannels;
 
    PxU32 mPad[2];
 
 
    void setup
        (const PxF32 graphSizeX, const PxF32 graphSizeY,
        const PxF32 engineGraphPosX, const PxF32 engineGraphPosY,
        const PxF32* const wheelGraphPosX, const PxF32* const wheelGraphPosY,
        const PxVec3& backgroundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
 
    void updateTimeSlice(const PxReal* const samples);
 
    void setChannel(PxVehicleGraphChannelDesc& desc, const PxU32 channel);
 
    void setupEngineGraph
        (const PxF32 sizeX, const PxF32 sizeY, const PxF32 posX, const PxF32 posY, 
        const PxVec3& backgoundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
 
    void setupWheelGraph
        (const PxF32 sizeX, const PxF32 sizeY, const PxF32 posX, const PxF32 posY, 
        const PxVec3& backgoundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
 
    PxVehicleGraph();
    ~PxVehicleGraph();
};
PX_COMPILE_TIME_ASSERT(PxU32(PxVehicleGraph::eMAX_NB_CHANNELS) >= PxU32(PxVehicleWheelGraphChannel::eMAX_NB_WHEEL_CHANNELS) && PxU32(PxVehicleGraph::eMAX_NB_CHANNELS) >= PxU32(PxVehicleDriveGraphChannel::eMAX_NB_DRIVE_CHANNELS));
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleGraph) & 15));
 
class PX_DEPRECATED PxVehicleTelemetryData
{
public:
 
    friend class PxVehicleUpdate;
 
    static PxVehicleTelemetryData* allocate(const PxU32 nbWheels);
 
    void free();
 
    void setup
        (const PxReal graphSizeX, const PxReal graphSizeY,
         const PxReal engineGraphPosX, const PxReal engineGraphPosY,
         const PxReal* const wheelGraphPosX, const PxReal* const wheelGraphPosY,
         const PxVec3& backGroundColor, const PxVec3& lineColorHigh, const PxVec3& lineColorLow);
 
    void clear();
 
    const PxVehicleGraph& getEngineGraph() const {return *mEngineGraph;}
 
    PxU32 getNbWheelGraphs() const {return mNbActiveWheels;}
 
    const PxVehicleGraph& getWheelGraph(const PxU32 k) const {return mWheelGraphs[k];}
 
    const PxVec3* getTireforceAppPoints() const {return mTireforceAppPoints;}
 
    const PxVec3* getSuspforceAppPoints() const {return mSuspforceAppPoints;}
 
private:
 
    PxVehicleGraph* mEngineGraph;
 
    PxVehicleGraph* mWheelGraphs;
 
    PxVec3* mTireforceAppPoints;
 
    PxVec3* mSuspforceAppPoints;
 
    PxU32 mNbActiveWheels;
 
    PxU32 mPad[3];
 
private:
 
    PxVehicleTelemetryData(){}
    ~PxVehicleTelemetryData(){}
};
 
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTelemetryData) & 15));
 
#endif //PX_DEBUG_VEHICLE_ON
 
//#endif // PX_DEBUG_VEHICLE_ON
 
#if !PX_DOXYGEN
} // namespace physx
#endif
 
#endif