| rFpro Host Name: | Host name or IP address of the rFpro Host machine. |
| Write Decimation Count: | Refresh rate for output data. Must be an integer greater than 1. |
| rFpro host receive port: | Port number used to receive data on the rFpro host. |
| Traffic Decimation Count: | Controls the refresh rate of traffic objects such as traffic vehicles, special actors, lights etc. |
| SimWB receive port: | Port number used to receive data from the rFpro host on the SimWB machine. |
| Axes Conversion: | Allows automatic conversion from a given coordinate system to rFPro coordinate system. |
| Support VI-DriveSim: | Click to automatically connect VI-DriveSim to rFpro. SimWB maps relevant RTDB items to rFpro I/O task |
| Vehicle Wheel Base: | Optionally change the wheel base (meters). |
| Vehicle Track: | Optionally change the vehicle track (meters). |
| CG Right Range: | Optionally change the CG right range (meters). |
| CG Rear Range: | Optionally change the CG rear range (meters). |
| CG Height: | Optionally change the CG height (meters). |
| Ride Height: | Optionally change the ride height (meters). |
| Field: | rFpro field name |
| Type: | Field data type |
| Mapped Points | Init Value: | Select a field on the left-hand-side of the I/O Mappings form. Then, click on a checkbox for an I/O point in the right-hand-side list of RTDB variables. See I/O Mappings... for details. |
| Description: | Field description |
The base license provides you with the ability to control own vehicle, motion platform, and proximity information. The traffic module allows you to control other traffic vehicles, special actors such as pedestrians, traffic lights, & sound (FMOD). It also allows user to query opponent vehicle states and control scene lights packets.
| Add: | Allows you to add Proximity, Traffic, SpecialActor, Light, FMOD, & OpponentStates using the drop-down menu. |
| Delete Selected: | Delete the selected packet. Please note that you can only delete the last packet. |
Using this you can control the own vehicle visualized in rFpro. The 'Output' node allows you to send information to rFpro and the 'Input' node allows you to receive information from rFpro.
Prerequisites:
- Make sure the rFpro is configured to use Remote Model Physics
- Change the RemoteModelPlugin.ini file and make sure the remote ip is configured to point at SimWB system
| Output.mET: | Elapsed time (at which this output state is valid ... rFpro may extrapolate briefly to synch with graphics |
| Output.mSkipInternalPhysics: | Request internal physics to be skipped for performance reasons; note that most valid flags probably need to be true for this to work well |
| Output.mUseInternalPhysics: | This indicates that plugin physics are temporarily invalid; rFpro should use its own internal calculations |
| Output.mPos.x: | Position (m) |
| Output.mPos.y: | Position (m) |
| Output.mPos.z: | Position (m) |
| Output.mOri[0].x: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[0].y: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[0].z: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[1].x: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[1].y: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[1].z: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[2].x: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[2].y: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mOri[2].z: | Orientation matrix (use conversion from TelemQuat if desired) |
| Output.mVel.x: | Velocity (m/s) (in world coordinates, not local!) |
| Output.mVel.y: | Velocity (m/s) (in world coordinates, not local!) |
| Output.mVel.z: | Velocity (m/s) (in world coordinates, not local!) |
| Output.mRot.x: | Rotation (rad/s) (in world coordinates, not local!) |
| Output.mRot.y: | Rotation (rad/s) (in world coordinates, not local!) |
| Output.mRot.z: | Rotation (rad/s) (in world coordinates, not local!) |
| Output.mAccelValid: | Whether mAccel is valid |
| Output.mAccel.x: | Linear acceleration (m/s2) (in world coordinates) |
| Output.mAccel.y: | Linear acceleration (m/s2) (in world coordinates) |
| Output.mAccel.z: | Linear acceleration (m/s2) (in world coordinates) |
| Output.mWheelPosValid: | Whether wheel positions are valid |
| Output.mWheelOriValid: | 0=invalid - rF will control, 2=full orientation (rFpro will *not* spin wheel other than for graphical extrapolation) [Do not use option 1] |
| Output.mTireParamsValid: | Whether slip angle, slip ratio, and tire load are valid |
| Output.mWheelRotationValid: | Whether rotations are valid |
| Output.mWheelBrakeTempValid: | Whether brake temps are valid |
| Output.mWheelTreadTempValid: | Whether tread temps are valid |
| Output.mWheelAirTempValid: | Whether air temps are valid |
| Output.mWheel[0].mPos.x: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mPos.y: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mPos.z: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[0].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[0].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[0].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[1].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[1].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[1].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[2].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[2].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mOri[2].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mSlipAngle: | Radians Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mSlipRatio: | Unitless, positive for traction. 0.0=0% slip, 1.0=100% slip Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mTireLoad: | Load on tire in Newtons Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mRotation: | Radians/sec Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mBrakeTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mTreadTemp[0]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mTreadTemp[1]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mTreadTemp[2]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[0].mAirTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mPos.x: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mPos.y: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mPos.z: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[0].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[0].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[0].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[1].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[1].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[1].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[2].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[2].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mOri[2].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mSlipAngle: | Radians Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mSlipRatio: | Unitless, positive for traction. 0.0=0% slip, 1.0=100% slip Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mTireLoad: | Load on tire in Newtons Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mRotation: | Radians/sec Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mBrakeTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mTreadTemp[0]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mTreadTemp[1]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mTreadTemp[2]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[1].mAirTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mPos.x: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mPos.y: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mPos.z: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[0].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[0].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[0].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[1].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[1].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[1].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[2].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[2].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mOri[2].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mSlipAngle: | Radians Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mSlipRatio: | Unitless, positive for traction. 0.0=0% slip, 1.0=100% slip Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mTireLoad: | Load on tire in Newtons Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mRotation: | Radians/sec Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mBrakeTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mTreadTemp[0]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mTreadTemp[1]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mTreadTemp[2]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[2].mAirTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mPos.x: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mPos.y: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mPos.z: | Center of wheel, in world coordinates Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[0].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[0].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[0].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[1].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[1].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[1].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[2].x: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[2].y: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mOri[2].z: | Orientation matrix Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mSlipAngle: | Radians Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mSlipRatio: | Unitless, positive for traction. 0.0=0% slip, 1.0=100% slip Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mTireLoad: | Load on tire in Newtons Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mRotation: | Radians/sec Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mBrakeTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mTreadTemp[0]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mTreadTemp[1]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mTreadTemp[2]: | Left/center/right, Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mWheel[3].mAirTemp: | Celsius Wheel info (front left, front right, rear left, rear right) |
| Output.mGearValid: | whether gear is valid |
| Output.mRPMValid: | whether engine RPM is valid |
| Output.mInputsValid: | whether throttle, brake, and steering are valid |
| Output.mGear: | -1=reverse, 0=neutral, 1+=forward gears |
| Output.mEngineRPM: | engine RPM (rotations per minute) |
| Output.mThrottle: | ranges 0.0-1.0 |
| Output.mBrake: | ranges 0.0-1.0 |
| Output.mSteering: | ranges -1.0-1.0 (left to right) |
| Output.mSteerTorqueValid: | ranges -1.0-1.0 (left to right) |
| Output.mSteerTorque: | ranges -1.0-1.0 (left to right) |
| Output.mHeadlightsValid: | ranges -1.0-1.0 (left to right) |
| Output.mHeadlightsOn: | ranges -1.0-1.0 (left to right) |
| Output.mRotAccelValid: | Whether angular acceleration is valid |
| Output.mRotAccel.x: | Rotational acceleration (rad/s^2) (in world coordinates) |
| Output.mRotAccel.y: | Rotational acceleration (rad/s^2) (in world coordinates) |
| Output.mRotAccel.z: | Rotational acceleration (rad/s^2) (in world coordinates) |
| Input.mDriverInputs.mSteering: | -1.0 to 1.0 |
| Input.mDriverInputs.mThrottle: | .0 to 1.0 |
| Input.mDriverInputs.mHandbrake: | .0 to 1.0 |
| Input.mDriverInputs.mBrakes: | .0 to 1.0 |
| Input.mDriverInputs.mClutch: | .0 to 1.0 |
| Input.mDriverInputs.mPowerDemand: | KERS or other |
| Input.mDriverInputs.mDirectManualShift: | -2=no selection/invalid, -1=reverse, 0=neutral, 1+=forward gear |
| Input.mDriverInputs.mShiftUp: | |
| Input.mDriverInputs.mShiftDown: | |
| Input.mDriverInputs.mShiftToNeutral: | |
| Input.mDriverInputs.mTCOverride: | |
| Input.mDriverInputs.mLaunchControl: | |
| Input.mDT: | Delta time to integrate through |
| Input.mET: | Elapsed time (at *end* of physics frame, not beginning) |
| Input.mAirDensity: | Current air density (which can be derived from: track altitude, ambient temp, humidity, and pressure) |
| Input.mHumidity: | Humidity (0.0-1.0) |
| Input.mPressure: | Air pressure (kPa) |
| Input.mAmbientTemp: | Temperature (Celsius) |
| Input.mTrackTemp: | Temperature (Celsius) |
| Input.mWind.x: | Wind velocity vector (m/s) |
| Input.mWind.y: | Wind velocity vector (m/s) |
| Input.mWind.z: | Wind velocity vector (m/s) |
| Input.mCollision: | Collision detected by internal rFpro physics (data below) |
| Input.mCollisionExitVector.x: | An optional position change to be applied in order to exit the collision |
| Input.mCollisionExitVector.y: | An optional position change to be applied in order to exit the collision |
| Input.mCollisionExitVector.z: | An optional position change to be applied in order to exit the collision |
| Input.mCollisionForce.x: | Collision force to be applied to main vehicle body |
| Input.mCollisionForce.y: | Collision force to be applied to main vehicle body |
| Input.mCollisionForce.z: | Collision force to be applied to main vehicle body |
| Input.mCollisionTorque.x: | Collision torque to be applied to main vehicle body |
| Input.mCollisionTorque.y: | Collision torque to be applied to main vehicle body |
| Input.mCollisionTorque.z: | Collision torque to be applied to main vehicle body |
| Input.mTyreContact[0].mSurfaceGain: | Friction multiplier. Should be exactly 1.0 for 'average' asphalt |
| Input.mTyreContact[0].mHeight: | Vertical position of the contact patch in world coordinates |
| Input.mTyreContact[0].mNormal.x: | Unit vector at normal to road surface (X) |
| Input.mTyreContact[0].mNormal.y: | Unit vector at normal to road surface (Y) |
| Input.mTyreContact[0].mNormal.z: | Unit vector at normal to road surface (Z) |
| Input.mTyreContact[0].mSurfaceType: | Surface type of road. 0=dry, 1=wet, 2=grass, 3=dirt, 4=gravel, 5=rumblestrip (under the centre of the tyre) |
| Input.mTyreContact[0].mHDvalid: | TRUE=valid HD contact data, all data members valid; FALSE=mPatchCentre is NOT valid |
| Input.mTyreContact[0].mPatchCentre.x: | The position (in world coordinates) of the centre of the contact patch (X) |
| Input.mTyreContact[0].mPatchCentre.y: | The position (in world coordinates) of the centre of the contact patch (Y) |
| Input.mTyreContact[0].mPatchCentre.z: | The position (in world coordinates) of the centre of the contact patch (Z) |
| Input.mTyreContact[1].mSurfaceGain: | Friction multiplier. Should be exactly 1.0 for 'average' asphalt |
| Input.mTyreContact[1].mHeight: | Vertical position of the contact patch in world coordinates |
| Input.mTyreContact[1].mNormal.x: | Unit vector at normal to road surface (X) |
| Input.mTyreContact[1].mNormal.y: | Unit vector at normal to road surface (Y) |
| Input.mTyreContact[1].mNormal.z: | Unit vector at normal to road surface (Z) |
| Input.mTyreContact[1].mSurfaceType: | Surface type of road. 0=dry, 1=wet, 2=grass, 3=dirt, 4=gravel, 5=rumblestrip (under the centre of the tyre) |
| Input.mTyreContact[1].mHDvalid: | TRUE=valid HD contact data, all data members valid; FALSE=mPatchCentre is NOT valid |
| Input.mTyreContact[1].mPatchCentre.x: | The position (in world coordinates) of the centre of the contact patch (X) |
| Input.mTyreContact[1].mPatchCentre.y: | The position (in world coordinates) of the centre of the contact patch (Y) |
| Input.mTyreContact[1].mPatchCentre.z: | The position (in world coordinates) of the centre of the contact patch (Z) |
| Input.mTyreContact[2].mSurfaceGain: | Friction multiplier. Should be exactly 1.0 for 'average' asphalt |
| Input.mTyreContact[2].mHeight: | Vertical position of the contact patch in world coordinates |
| Input.mTyreContact[2].mNormal.x: | Unit vector at normal to road surface (X) |
| Input.mTyreContact[2].mNormal.y: | Unit vector at normal to road surface (Y) |
| Input.mTyreContact[2].mNormal.z: | Unit vector at normal to road surface (Z) |
| Input.mTyreContact[2].mSurfaceType: | Surface type of road. 0=dry, 1=wet, 2=grass, 3=dirt, 4=gravel, 5=rumblestrip (under the centre of the tyre) |
| Input.mTyreContact[2].mHDvalid: | TRUE=valid HD contact data, all data members valid; FALSE=mPatchCentre is NOT valid |
| Input.mTyreContact[2].mPatchCentre.x: | The position (in world coordinates) of the centre of the contact patch (X) |
| Input.mTyreContact[2].mPatchCentre.y: | The position (in world coordinates) of the centre of the contact patch (Y) |
| Input.mTyreContact[2].mPatchCentre.z: | The position (in world coordinates) of the centre of the contact patch (Z) |
| Input.mTyreContact[3].mSurfaceGain: | Friction multiplier. Should be exactly 1.0 for 'average' asphalt |
| Input.mTyreContact[3].mHeight: | Vertical position of the contact patch in world coordinates |
| Input.mTyreContact[3].mNormal.x: | Unit vector at normal to road surface (X) |
| Input.mTyreContact[3].mNormal.y: | Unit vector at normal to road surface (Y) |
| Input.mTyreContact[3].mNormal.z: | Unit vector at normal to road surface (Z) |
| Input.mTyreContact[3].mSurfaceType: | Surface type of road. 0=dry, 1=wet, 2=grass, 3=dirt, 4=gravel, 5=rumblestrip (under the centre of the tyre) |
| Input.mTyreContact[3].mHDvalid: | TRUE=valid HD contact data, all data members valid; FALSE=mPatchCentre is NOT valid |
| Input.mTyreContact[3].mPatchCentre.x: | The position (in world coordinates) of the centre of the contact patch (X) |
| Input.mTyreContact[3].mPatchCentre.y: | The position (in world coordinates) of the centre of the contact patch (Y) |
| Input.mTyreContact[3].mPatchCentre.z: | The position (in world coordinates) of the centre of the contact patch (Z) |
| Input.mLocationFlags: | Vehicle location flags. bit 1: in pits. bits 2-32: unused |
| Input.mBeaconFlags: | Bits 1-6: beacon flags. bits 7-32: unused |
| Input.mTyreContactExtras[0].mTerrainName: | The material prefixes from the TDF file |
| Input.mTyreContactExtras[1].mTerrainName: | The material prefixes from the TDF file |
| Input.mTyreContactExtras[2].mTerrainName: | The material prefixes from the TDF file |
You can use this to control motion platform managed by rFpro.
| Output.mET: | Motion Platform Output: Elapsed time (at which this output state is valid) |
| Output.mPos.x: | Motion Platform Output: Position (relative to origin) |
| Output.mPos.y: | Motion Platform Output: Position (relative to origin) |
| Output.mPos.z: | Motion Platform Output: Position (relative to origin) |
| Output.mOri[0].x: | Motion Platform Output: Orientation Matrix |
| Output.mOri[0].y: | Motion Platform Output: Orientation Matrix |
| Output.mOri[0].z: | Motion Platform Output: Orientation Matrix |
| Output.mOri[1].x: | Motion Platform Output: Orientation Matrix |
| Output.mOri[1].y: | Motion Platform Output: Orientation Matrix |
| Output.mOri[1].z: | Motion Platform Output: Orientation Matrix |
| Output.mOri[2].x: | Motion Platform Output: Orientation Matrix |
| Output.mOri[2].y: | Motion Platform Output: Orientation Matrix |
| Output.mOri[2].z: | Motion Platform Output: Orientation Matrix |
| Output.mVel.x: | Motion Platform Output: Velocity |
| Output.mVel.y: | Motion Platform Output: Velocity |
| Output.mVel.z: | Motion Platform Output: Velocity |
| Output.mRot.x: | Motion Platform Output: Rotation |
| Output.mRot.y: | Motion Platform Output: Rotation |
| Output.mRot.z: | Motion Platform Output: Rotation |
Object proximity fields can provide position information about nearby static scene objects to the main vehicle. For example, it can be used to output information about close proximity to side walls & barriers, which can be used to feed aero models.
You can define a set of points and ray vectors around the vehicle. If they intersect with any static scenery, then information about what they have intersected with is returned.
A proximity query consists of the following variables:
| mPos (mPos.x; mPos.y; mPos.z): | Offset from vehicle, mPos, in local vehicle coordinates. |
| mRay (mRay.x; mRay.y; mRay.z): | Vector (direction and range) to scan for objects in local vehicle coordinates. |
For each query, you must map all 6 variables (mPos.x, mPos.y, mPos.z, mRay.x, mRay.y, mRay.z). Also, when mapping more than 1 query, you must map them contiguously and start at point 0. That is, for X proximity queries, you must map points 0 through X-1. You cannot map 0 through X-2 and X or any other combination.
Each proximity query yields one proximity response. Because you can specify up to 10 queries, you can specify up to 10 responses.
A response consists of the following variables:
| Valid (mValid): | Boolean denoting whether each point/ray has intersected any object. Note the other variables of the response retain their last good value, so this field must be taken into consideration to know the validity of the other response variables. |
| Range (mRange): | Distance from query point to surface of closest object (metres). |
| Normal (mNormal.x; mNormal.y; mNormal.z): | Unit normal vector of surface that the ray has intersected. |
| Instance Name (mInstanceName): | Name of the object instance (possibly truncated, 20 characters long) . |
| Material Name (mMaterialName): | Name of the surface material (possibly truncated, 20 characters long). |
Proximity responses and queries form corresponding pairs. That is, proximity response 0 corresponds to proximity query 0, etc.
The diagram to the right depicts 4 vectors (V1-4), which have offsets (O1-4) from the vehicle, mPos. The nearest object interesecting each of the vectors will be reported.
There may be performance implications of a large number of query points.
You can use this to add and control additional traffic vehicles in rFpro. This is useful in simulating traffic along with own vehicle.
Use the 'ConfigData' to specify the type of vehicle that you want to add and name of the driver etc. And, use the 'State' node to control the added additional vehicle.
| ConfigData | |
| DriverName(mDriverName): | If empty, will use default from VEH file |
| Helmet(mHelmet): | Helmet name (set empty for default) |
| Skin(mSkin): | Skin name (set empty for default) |
| UpgradePack(mUpgradePack): | Coded upgrades (recommend to set to all zeroes if unknown). Size eight characters |
| VehFile(mVehFile): | Name of the VEH file (no path, with or without extension .VEH) |
| State | |
| Brake(mBrake): | Ranges 0.0-1.0 |
| Brakelights(mBrakelights): | Brakelight override: 0=invalid (rF control)); 1=force off, 2=force on |
| Collidable(mCollidable): | Can this vehicle be collided with? |
| ET(mET): | Elapsed time |
| EngineRPM(mEngineRPM): | Engine RPM (rotations per minute) |
| Gear(mGear): | -1=reverse, 0=neutral, 1+=forward gears |
| GearValid(mGearValid): | Whether gear is valid |
| Heading(mHeading): | Heading angle, in radians |
| HeadingValid(mHeadingValid): | Only if full orientation is invalid, we'll try to use simple heading instead |
| Headlights(mHeadlights): | Headlight override: 0=invalid (rF control)); 1=force off, 2=force on |
| ID(mID): | Slot ID (note that it can be re-used in multiplayer after someone leaves) |
| InputsValid(mInputsValid): | Whether throttle, brake, and steering are valid |
| ManualTransparency(mManualTransparency): | For manual transparency: 0.0 = visible, 1.0 = invisible, can be used to indicate confidence in data |
| OriValid(mOriValid): | Whether the orientation matrix is valid (if invalid, will use AI simulation) |
| Ori[0](mOri[0].x; mOri[0].y; mOri[0].z): | Orientation matrix (use conversion from TelemQuat if desired) |
| Ori[1](mOri[1].x; mOri[1].y; mOri[1].z): | Orientation matrix (use conversion from TelemQuat if desired) |
| Ori[2](mOri[2].x; mOri[2].y; mOri[2].z): | Orientation matrix (use conversion from TelemQuat if desired) |
| Pos(mPos.x; mPos.y; mPos.z): | Position (m).x should always be valid. Position (m).z should always be valid |
| PosYValid(mPosYValid): | Whether the y (height) coordinate is valid (if invalid, will use HAT) |
| PurgeFlag(mPurgeFlag): | Flag to remove any previously stored states (could be used to start a new lap, for example) |
| RPMValid(mRPMValid): | Whether engine RPM is valid |
| Rot(mRot.x; mRot.y; mRot.z): | World rotation (sorry, telemetry reports local velocity but we can't convert if optional orientation is invalid!) |
| RotValid(mRotValid): | Whether rotation is valid (if invalid, will use AI simulation) |
| Steering(mSteering): | Ranges -1.0-1.0 (left to right) |
| Throttle(mThrottle): | Ranges 0.0-1.0 |
| TransparentProximity(mTransparentProximity): | For automatic transparency: 0.0 = off, 2.0-62.0 = fully visible at this distance from the vehicle that camera is focusing on, and totally invisible at 1/4th of that distance |
| Vel(mVel.x; mVel.y; mVel.z): | Velocity |
| VelValid(mVelValid): | Whether velocity is valid (if invalid, will use AI simulation) |
| WheelBrakeTempsValid(mWheelBrakeTempsValid): | Whether wheel brake temps are valid |
| WheelRotationsValid(mWheelRotationsValid): | Whether wheel rotations are valid |
| WheelYLocationsValid(mWheelYLocationsValid): | Whether wheel y locations are valid |
| Wheel[0](mWheel[0].mBrakeTemp; mWheel[0].mRotation; mWheel[0].mYLocation): | |
| Wheel[1](mWheel[1].mBrakeTemp; mWheel[1].mRotation; mWheel[1].mYLocation): | |
| Wheel[2](mWheel[2].mBrakeTemp; mWheel[2].mRotation; mWheel[2].mYLocation): | |
| Wheel[3](mWheel[3].mBrakeTemp; mWheel[3].mRotation; mWheel[3].mYLocation): |
You can use this to add and control special actors such as pedestrians, bicycles, motor cycles, animals, and etc.
A SpecialActor query consists of the following variables:
| ET(mET): | Elapsed time |
| Heading(mHeading): | Heading angle, in radians |
| HeadingValid(mHeadingValid): | Is heading angle valid |
| Name(mName): | Special actor name |
| Pos(mPos.x; mPos.y; mPos.z): | |
| SpecialType(mSpecialType): | Pedestrian - 0, Bicycle - 1, & Motorcycle - 2 |
| Type(mType): | Type |
You can use this to control traffic lights, lights in the vehicle, and etc.
A Light query consists of the following variables:
| ExactTrueOrWildCardFalse(exacttrueorwildcardfalse): | True - Match name exactly. False - Use name a wild card to match light objects |
| Name(name): | Name of the light object |
| OnVehicle(onvehicle): | True - Light is on EGO vehicle. False - Light is elsewhere |
| State(state): | Light state |
You can use this to control FMOD sound engine that is configured with rFpro. FMOD sound sets have lower latency and more flexibility.
A FMOD query consists of the following variables:
| Name(name): | Name of FMOD parameter |
| Value(value): | New value of FMOD parameter |
Use this to obtain some basic information about vehicles near to the main physics vehicle. This information could be used to model aero effects in a racing scenario, or as truth data in a sensor modelling scenario.
A UDP packet containing up to the number of vehicles specified will be sent to the model. The position, orientation and first derivates will be sent, as well the square of the distance between the physics vehicle and each opponent.
The list of vehicles will be sorted by distance from the physics vehicle and so could change dynamically. There is an ID field if it is necessary to track a specific vehicle.
OpponentStates packet consists of the following variables:
| DistanceSquared(mDistanceSquared): | Square of distance to opoonent |
| ID(mID): | slot ID (note that it can be re-used in mtabletiplayer after someone leaves) |
| Ori[0](mOri[0].x; mOri[0].y; mOri[0].z): | Orientation matrix (use conversion from TelemQuat if desired) |
| Ori[1](mOri[1].x; mOri[1].y; mOri[1].z): | Orientation matrix (use conversion from TelemQuat if desired) |
| Ori[2](mOri[2].x; mOri[2].y; mOri[2].z): | Orientation matrix (use conversion from TelemQuat if desired) |
| Pos(mPos.x; mPos.y; mPos.z): | Position (m).x should always be valid. Position (m).z should always be valid |
| Rot(mRot.x; mRot.y; mRot.z): | World rotation (sorry, telemetry reports local velocity but we can't convert if optional orientation is invalid!) |
| Vel(mVel.x; mVel.y; mVel.z): | Velocity |
The number of scene lights are fixed.
A SceneLights query consists of the following variables:
| FlagPostID(mFlagPostID): | Unimplemented |
| FlagState(mFlagState): | Set to: -2 Ignore this message/Do not change, 0 Off, 1 Green, 2 Yellow, 3 Red, 4 Blue, 5 Safety Car |
| PitCrew(mPitCrew): | Pit Crew |
| PitEntry(mPitEntry): | Set to: -2 Ignore this message/Do not change, -1 rFpro controlled, 0 Green, 1 Green & Blue, 2 Red |
| PitExit(mPitExit): | Set to: -2 Ignore this message/Do not change, -1 rFpro controlled, 0 Green, 1 Green & Blue, 2 Red |
| StartAmber(mStartAmber): | Set to: -2 Ignore this message/Do not change, 0 Off, 1 On |
| StartGreen(mStartGreen): | Set to: -2 Ignore this message/Do not change, 0 Off, 1 On |
| StartLights(mStartLights): | Set to: -2 Ignore this message/Do not change, -1 rFpro controlled, 0 All lamps off, 1-5 Number of lit lamps |
This feature can be used to automatically map relevant RTDB points from a VI-DrivSim RTDB to rFpro. Enabling this checkbox allows user to specify vehicle constants if needed. The rFpro IO task then obtains the data from VI-DriveSim and sends it over to rFpro for visualization after performing required reference system modification.
