T3D 1.2 meshRoad fix for PhysX version not having collision

This fix will add PhysX collision to the mesh roads.

The lines of code I added are commented as "Added"
The lines of code I changed are commented as "Changed".
I left some source code lines before and after the changes to find where the lines need to be added to code instead of using line numbers.
Note that _addShapeToPhysX() is a new function.

Added the following lines of code to meshRoad.h

#include "materials/matInstance.h"
#endif
#ifndef _CONVEX_H_
#include "collision/convex.h"
#endif

class PhysicsBody;  // Added
class PhysicsWorld; // Added

//extern U32 gIdxArray[6][2][3];

struct MeshRoadHitSegment
{
   U32 idx;

void _regenerate();
   void _generateSlices();
   void _generateSegments();
   void _generateVerts();

   void _addShapeToPhysX(); // Added

protected:

MeshRoadSliceVector mSlices;
   MeshRoadNodeVector mNodes;
   MeshRoadSegmentVector mSegments;
      
   // Fields.
   F32 mTextureLength;
   F32 mBreakAngle;
   S32 mWidthSubdivisions;

   F32 mStaticFriction;  // Added
   F32 mKineticFriction; // Added
   F32 mRestitution;     // Added
   
   // Collision and Physics.
   Convex* mConvexList;
   Vector<MeshRoadConvex*> mDebugConvex;
   PhysicsBody *mPhysicsRep;
   PhysicsWorld *mWorld;  // Added
};

Added the following lines of code to meshRoad.cpp

#include "materials/shaderData.h"
#include "gfx/sim/gfxStateBlockData.h"
#include "gfx/sim/debugDraw.h"
#include "collision/concretePolyList.h"
#include "T3D/physics/physicsPlugin.h"
#include "T3D/physics/physicsBody.h"
#include "T3D/physics/physicsWorld.h"
#include "T3D/physics/physicsCollision.h" // Added
#include "environment/nodeListManager.h"  // Added

#define MIN_METERS_PER_SEGMENT 1.0f
#define MIN_NODE_DEPTH 0.25f
#define MAX_NODE_DEPTH 50.0f
#define MIN_NODE_WIDTH 0.25f

MeshRoad::MeshRoad()
		: mTextureLength( 5.0f ),
		  mBreakAngle( 3.0f ),
		  mPhysicsRep( NULL ),
                  mWorld( NULL ),            // Added
		  mWidthSubdivisions( 0 ),
		  mStaticFriction( 1.2f ),   // Added
		  mKineticFriction( 1.2f ),  // Added
		  mRestitution( 0.597f )     // Added
{

addField( "widthSubdivisions", TypeS32, Offset( mWidthSubdivisions, MeshRoad ), 
         "Subdivide segments widthwise this many times when generating vertices." );

	  addField( "staticFriction", TypeF32, Offset( mStaticFriction, MeshRoad ), 
		"Road friction when the wheel is not slipping (has traction)." );      // Added

	  addField( "kineticFriction", TypeF32, Offset( mKineticFriction, MeshRoad ),
		"Road friction when the wheel is slipping (no traction)." );           // Added

	  addField( "restitution", TypeF32, Offset( mRestitution, MeshRoad ),
		"Road restitution.nCurrently unused." );                              // Added

   endGroup( "MeshRoad" );

void MeshRoad::onRemove()
{
   removeFromScene();            // Added

   SAFE_DELETE( mPhysicsRep );
   mWorld = NULL;               //Added

   mConvexList->nukeList();

   for ( U32 i = 0; i < SurfaceCount; i++ )
   {
      SAFE_DELETE( mMatInst[i] );
   }


   Parent::onRemove();
}

stream->write( mTextureLength );      
      stream->write( mBreakAngle );
      stream->write( mWidthSubdivisions );

	  // Write physics materials
      stream->write( mStaticFriction );   // Added
      stream->write( mKineticFriction );  // Added
      stream->write( mRestitution );      // Added
   }

   if ( stream->writeFlag( mask & NodeMask ) )
   {
      const U32 nodeByteSize = 32; // Based on sending all of a node's parameters

stream->read( &mBreakAngle );
      stream->read( &mWidthSubdivisions );

	  // Read physics materials
      stream->read( &mStaticFriction );       // Added
      stream->read( &mKineticFriction );      // Added
      stream->read( &mRestitution );          // Added
   }

   // NodeMask
   if ( stream->readFlag() )
   {
      if (stream->readFlag())

This is actually a fix to the code that I posted earlier.

{
      const MeshRoadSlice &slice = mSlices[i];

      if ( i == 0 )
      {
         box.minExtents = slice.p0;
         box.maxExtents = slice.p0;  // Changed
         box.extend( slice.p2 );     // Added
         box.extend( slice.pb0 );
         box.extend( slice.pb2 );
      }
      else
      {
         box.extend( slice.p0 );

mSegments.push_back( seg );
   }

   if ( isClientObject() )
      _generateVerts();

   _addShapeToPhysX(); // Added
}

void MeshRoad::_generateVerts()
{           
   const U32 widthDivisions = getMax( 0, mWidthSubdivisions );
   const F32 divisionStep = 1.0f / (F32)( widthDivisions + 1 );

This whole function is new.

// Add shape to PhysX engine
void MeshRoad::_addShapeToPhysX()
{
	if ( PHYSICSMGR )
	{
		SAFE_DELETE( mPhysicsRep );
		mWorld = NULL;

		// If we aren't dynamic we don't need to tick.   
		setProcessTick( false );

		mWorld = PHYSICSMGR->getWorld( isServerObject() ? "server" : "client" );

		if( mWorld )
		{
			mPhysicsRep = PHYSICSMGR->createBody();

			if( mPhysicsRep )
			{
				PhysicsCollision *colShape = PHYSICSMGR->createCollision();

				if( colShape )
				{
					Point3F p[8];

					// Points already in world coordinates so we don't need to translate them 
					for( int i = 0, j = 1; j < mSlices.size(); i++, j++ )
					{
						p[0] = mSlices[i].pb0;
						p[1] = mSlices[i].p0;
						p[2] = mSlices[i].p2;
						p[3] = mSlices[i].pb2;

						p[4] = mSlices[j].pb0;
						p[5] = mSlices[j].p0;
						p[6] = mSlices[j].p2;
						p[7] = mSlices[j].pb2;
		
						colShape->addConvex( &p[0], 8,  MatrixF::Identity );
					}

					mPhysicsRep->init( colShape, 0.0f, 0, this, mWorld );

					mPhysicsRep->setMaterial( mRestitution, mKineticFriction, mStaticFriction );
					mPhysicsRep->setTransform(  MatrixF::Identity );
				}
			}
		}
	}
}

//-------------------------------------------------------------------------
// Console Methods
//-------------------------------------------------------------------------

DefineEngineMethod( MeshRoad, setNodeDepth, void, ( S32 idx, F32 meters ),,