Auto Bounds

add the following to the TSShapeinstance class in TSShapeinstance.h

void computeBounds(const VectorF &WorldScale, Box3F &LocalBounds);

add the following to TSShapeinstance.cc

void TSShapeInstance::computeBounds(const VectorF &WorldScale, Box3F &LocalBounds)
{
	// this method is called by both client and server, once per tick

	S32 dl=getCurrentDetail();  //  or you can also specify a different detail, for instance,
	// you may construct a very low poly mesh purely for the purpose of getting the bounds
	// in which case you need to set dl to whatever detail to use
        // (your lowest LOD would be clever...)


    animate(); // strike a pose from the current timescale of the current animation thread

   // get subshape and object detail
   const TSDetail * detail = &mShape->details[dl];
   S32 ss = detail->subShapeNum;
   S32 od = detail->objectDetailNum;

   // set up static data
   setStatics(dl);

   S32 start = mShape->subShapeFirstObject[ss];
   S32 end   = mShape->subShapeNumObjects[ss] + start;

   // run through objects and updating bounds as we go
   Box3F bounds;
   bounds.min.set( 10E30f, 10E30f, 10E30f);
   bounds.max.set(-10E30f,-10E30f,-10E30f);
   bool complete=false;
   for (S32 i=start; i<end; i++)
   {
	   MeshObjectInstance * mesh = &mMeshObjects[i];
	   if (od >= mesh->object->numMeshes)
		   continue;  

	   if (mesh->getMesh(od))
	   {		   
		   TSMesh *m = mesh->getMesh(od); 
		   MatrixF LocalTransform;	  
		   /*
		   S32 groundNode = getShape()->findNode("Ground");
		   if(groundNode > 0)				
		       LocalTransform.mul(*mesh->getTransform(), mNodeTransforms[groundNode]);
		   else  */
			   LocalTransform = *mesh->getTransform(); 
           
                   // for the player class, we only care about skin mesh
		   if (m->getMeshType()==TSMesh::SkinMeshType)
		   {
			   TSSkinMesh * skin = (TSSkinMesh*)m;
			   skin->updateSkin(); // this will move the vertices into the currecnt pose
			   Point3F p;
			   for (S32 vert=0; vert< m->vertsPerFrame; vert++)
			   {
				   LocalTransform.mulP(m->verts.address()[vert],&p);
				   bounds.max.setMax(p);
				   bounds.min.setMin(p);
			   }
                           complete=true;
		   }
	   }
   }
   clearStatics();
   
   bounds.min.convolve(WorldScale);
   bounds.max.convolve(WorldScale);
   if(complete)
      LocalBounds = bounds;
   
}

In player.cc, locate Player::processTick and right at the top of the method add

mShapeInstance->computeBounds(getScale(), mObjBox); //duncan autobounds
resetRenderWorldBox(); //duncan autobounds
resetWorldBox();  //duncan autobounds
onScaleChanged(); //duncan autobounds

Thats all you need to change.

This method does add a slight bit more CPU time to the process tick method, so ideally you should move the updateTick additions to a location where they will only be called when you change a player position or scale etc.

Having an always accurate bounds box can have advantages in reducing time in other functions like cast-ray etc.

So comment out any bounds box modifying code from those other resources if you are using them.

For the Custom Shape Mod people, scaling everything from the waist up works fine. Scaling the legs up will have you players feet sticking through the terrain until you perform a jump which will sort out the problem.

It's probably possible to add a Z offset to the transform equal to the amount to scaled up by which should raise the player back up to ground level, but I have not played with that yet. If you get a neat solution, let me know.