Alternate Collision Masks

Download Code File

I originally created this code to allow players to pass thru the atlas terrain while in an interior.


This resource will allow you to set an objects collision mask on the fly between a standard mask and an alternate one.
This is useful for when you need an object like the player to not collide with the terrain while inside an interior.
While the setempty option can be used on a legacy/mega terrain to do the same thing , there are situations were this is not practical.
The setempty method creates a square hole in the terrain and depending on your needs your interior might not perfectly align itself to the empty hole.
And as for TGEA's atlas terrains go , there is no setempty option.


We start with gamebase.h.
Change

enum GameBaseMasks {
      InitialUpdateMask =     Parent::NextFreeMask,
      DataBlockMask =         InitialUpdateMask << 1,
      ExtendedInfoMask =      DataBlockMask << 1,
      ControlMask =           ExtendedInfoMask << 1,
      NextFreeMask =          ControlMask << 1
   };

To

enum GameBaseMasks {
      InitialUpdateMask =     Parent::NextFreeMask,
      DataBlockMask =         InitialUpdateMask << 1,
      ExtendedInfoMask =      DataBlockMask << 1,
      ControlMask =           ExtendedInfoMask << 1,
      CollisionMask =	      ControlMask << 1,
      NextFreeMask =          CollisionMask << 1
   };

Then add

bool mUseAlternateCollision;
	void UpdateCollisionMask();

   //New collision Masks
   U32 sAlternateCollisionMask;
   U32 sStandardCollisionMask;

   //Projectile , Debris
   U32 csmStaticCollisionMask;
   U32 csmDynamicCollisionMask;

   //Player , FlyingVehicle , HoverVehicle , RigidShape , Item , WheeledVehicle
   //This is for future changes. Don't uncomment unless you are actually using them. 
   //It will cause problems if you don't set them up correctly.
   //U32 sCollisionMoveMask;
   //U32 sServerCollisionContactMask;
   //U32 sClientCollisionContactMask;
   //U32 sServerCollisionMask;
   //U32 sClientCollisionMask;

   void SetStandardCollision(bool UseStandardCollision);

to a public area of the Gamebase decleration

Just after DECLARE_CONOBJECT(GameBase); would be fine.

Now open GameBase.cc/cpp and add to the end of GameBase::packUpdate

if (stream->writeFlag(mask & CollisionMask))
   {
stream->writeFlag(mUseAlternateCollision);

	  }

just before

return 0;

Then add to the end of GameBase::unpackUpdate

if (stream->readFlag())
   {
 mUseAlternateCollision = stream->readFlag();
   }

Then add

void GameBase::SetStandardCollision(bool Collide)
   {

mUseAlternateCollision = !Collide;
setMaskBits(CollisionMask);
   }

ConsoleMethod( GameBase, SetStandardCollision, void, 3, 3, "SetStandardCollision True or False")
{
   return object->SetStandardCollision(dAtob(argv[2]));
}

	void GameBase::UpdateCollisionMask()
		{
if(mUseAlternateCollision)
	{
csmStaticCollisionMask = sAlternateCollisionMask;

	}
 else
	 {
csmStaticCollisionMask = sStandardCollisionMask;

	}
		}

To the end of Gamebase.cc/cpp
Ok done with gamebase.


Ok heres how the alternate collision masking works.
All the classes that use collision masks derive from GameBase.
Using the Projectile class as an example.
Comment out or delete the defines for csmStaticCollisionMask and csmDynamicCollisionMask.
Just the defines not all the references for them.
We are moving the defines to GameBase.h.
Just comment out or delete the following from projectile.cc

const U32 Projectile::csmStaticCollisionMask =  TerrainObjectType    |
                                                InteriorObjectType   |
                                                StaticObjectType;
   const U32 Projectile::csmDynamicCollisionMask = PlayerObjectType        |
                                                VehicleObjectType       |
                                                DamagableItemObjectType;

Then move it to the Projectile constructor like this.

mUseAlternateCollision = false;

   sStandardCollisionMask = TerrainObjectType | InteriorObjectType | StaticObjectType;
   sAlternateCollisionMask = InteriorObjectType;
   
   csmStaticCollisionMask = sStandardCollisionMask;
   csmDynamicCollisionMask = PlayerObjectType | VehicleObjectType | DamagableItemObjectType;
   csmDamageableMask = csmDynamicCollisionMask;

sStandardCollisionMask will hold the original collision mask and
sAlternateCollisionMask will hold the alternate mask.

Then comment out or delete

static const U32 csmStaticCollisionMask;
    static const U32 csmDynamicCollisionMask;

From projectile.h
And change csmDamageableMask from

static const U32 csmDamageableMask;

to

U32 csmDamageableMask;

Now place

UpdateCollisionMask();

In Projectile::processTick before

if (getContainer()->castRay(oldPosition, newPosition, csmDynamicCollisionMask | csmStaticCollisionMask, &rInfo) == true)

to determine if you should use the default or alternate collision mask.

I used the projectile class as an example but you should get the idea.
To use a different class like the Player just do the same thing.
Comment out or delete the original static collision masks defines.
Move them to the constructor with sStandardCollisionMask used as the original mask and sAlternateCollisionMask used as the alternate mask.
Add

void UpdateCollisionMask();

to the header

and in Player.cc/cpp add

void Player::UpdateCollisionMask()
		{
if(mUseAlternateCollision)
	{
"original collision mask name" = sAlternateCollisionMask;

	}
 else
	 {
"original collision mask name" = sStandardCollisionMask;

	}
		}

Then in Player::processtick you add

UpdateCollisionMask();

before the first castray that uses the collision masks.


Then from script call

%object.SetStandardCollision(false);

To use the alternate collison mask.
And use

%object.SetStandardCollision(true);

To use the original mask.

Enjoy.