Mounting ParticleEmitterNodes

Developed with TGE 1.5.2.

I decided I'd like the ability to mount particle emitters to a node in a ShapeBase object after thinking about flamethrowers. I think you get the idea.

Anyway, I'm not going to waffle: here are the code changes.

In particleEmitter.h:

This is just infrastructure - making sure the particle code 'knows' about the ShapeBase code.
Find:

#ifndef _GAMEBASE_H_
#include "game/gameBase.h"
#endif

And add beneath it:

//Dan's mods (mounting particles) ->
#ifndef _SHAPEBASE_H_
#include "game/shapeBase.h"
#endif
//<- Dan

Next, we're going to declare some simple additions to the ParticleEmitterNode class. ParticleEmitterNodes are basically invisible point objects that emit particles. What we want to do is add two things: an object and a mount node. So why three fields? Script compatability. It's complicated.
And why the method? onDeleteNotify is called on objects when another object is deleted. Here, we use it to see whether the parent object of our ParticleEmitterNode is deleted. If so, we'll want to do something.
Find:

ParticleEmitterNodeData* mDataBlock;

And add beneath:

//Dan's mods (mounting particles) ->
   S32 mMountObject;
   ShapeBase* mMount;
   S32 mMountNode;

   void onDeleteNotify(SimObject*);
   //<- Dan

processTick and interpolateTick are methods that allow an object to do something over time. They are called periodically on all objects.
Find:

// Time/Move Management
  public:

And add beneath:

//Dan's mods (mounting particles) ->
   void processTick(const Move* move);
   void interpolateTick(F32 dt);
   //<- Dan

In particleEmitter.cc

Again, administration.
Find:

#include "math/mathIO.h"

And add beneath:
(Thanks to Pifford for pointing out that netConnection.h needs to be included.)

//Dan's mods (mounting particles) ->
#include "game/shapeBase.h"
#include "sim/netConnection.h"
//<- Dan

Now, those fields that we added to ParticleEmitterNode need to be initialised, so they don't unexpectedly contain junk, which could cause bad things to happen.
Find:

mEmitterDatablock   = NULL;
   mEmitterDatablockId = 0;
   mEmitter            = NULL;
   mVelocity           = 1.0;

And add beneath:

//Dan's mods (mounting particles) ->
   mMountObject = -1;
   mMount = NULL;
   mMountNode = -1;
   //<- Dan

The initPersistFields method exposes a bunch of object fields to script. Note that only two of our three added fields are exposed to scripts.
Find:

addField("emitter",  TypeParticleEmitterDataPtr, Offset(mEmitterDatablock, ParticleEmitterNode));
   addField("velocity", TypeF32,                    Offset(mVelocity,         ParticleEmitterNode));

And add beneath:

//Dan's mods (particle mounting) ->
   addField("mountObject",TypeS32,Offset(mMountObject,ParticleEmitterNode));
   addField("mountNode",TypeS32,Offset(mMountNode,ParticleEmitterNode));
   //<- Dan

This is where that third field comes in. We use the integer we were passed from script to find an actual object pointer. Then we just perform some common-sense checks to make sure our data makes sense.
Find:

if (isClientObject())
   {
      ParticleEmitter* pEmitter = new ParticleEmitter;
      pEmitter->onNewDataBlock(mEmitterDatablock);
      if (pEmitter->registerObject() == false)
      {
         Con::warnf(ConsoleLogEntry::General, "Could not register base emitter for particle of class: %s", mDataBlock->getName());
         delete pEmitter;
         return false;
      }
      mEmitter = pEmitter;
   }

And add beneath:

//Dan's mods (mounting particles) ->
   //If we're a server object, resolve mount object
   else
   {
	   ShapeBase* ptr;
	   mMount = NULL;
	   if(mMountObject != -1)
		   if(Sim::findObject(mMountObject,ptr))
		   {
			   mMount = ptr;
			   deleteNotify(ptr);
			   //And while we're at it, check mount
			   if(mMountNode != -1)
				   if(mMountNode > ShapeBaseData::NumMountPoints)
				   {
					   Con::errorf("ParticleNodeEmitter::onAdd: mountNode too big!");
					   mMountNode = -1;
				   }
		   }
   }
   //<- Dan

This is the meat of the code. Here we declare the processTick, interpolateTick, and onDeleteNotify methods. Let's break them down:

processTick: every tick, if we're mounted to an object, we get the posiion and rotation of the node we're mounted to, and set our own position and rotation to be equal. I copied this code from StaticShape, which has simple mounting like this.

interpolateTick: this is called in the spaces between ticks. In this method, we do basically the same thing, but we use render transforms instead of regular ones. Don't ask me what the difference is.

onDeleteNotify: basically, if the object deleted was our mount object, we clear out the object from memory. Ideally, we should just delete the emitter. I'll add it to my to do list.

Find:

bool ParticleEmitterNode::onNewDataBlock(GameBaseData* dptr)
{
   mDataBlock = dynamic_cast<ParticleEmitterNodeData*>(dptr);
   if (!mDataBlock || !Parent::onNewDataBlock(dptr))
      return false;

   // Todo: Uncomment if this is a "leaf" class
   scriptOnNewDataBlock();
   return true;
}

//--------------------------------------------------------------------------

And add beneath:

//Dan's mods (mounting particles) ->
void ParticleEmitterNode::processTick(const Move* move)
{
	//If we have a mount object
	if(mMount)
	{
		MatrixF mat;
		//If we have a valid mount
		if(mMountNode != -1)
			mMount->getMountTransform(mMountNode,&mat);
		//Otherwise, use centre
		else
			mat = mMount->getTransform();
		//Set transforms
		Parent::setTransform(mat);
		Parent::setRenderTransform(mat);
	}
}

void ParticleEmitterNode::interpolateTick(F32 dt)
{
	//If we have a mount object
	if(mMount)
	{
		MatrixF mat;
		//If we have a valid mount
		if(mMountNode != -1)
			mMount->getRenderMountTransform(mMountNode,&mat);
		//Otherwise, use centre
		else
			mat = mMount->getRenderTransform();
		//Set render transform
		Parent::setRenderTransform(mat);
	}
}

void ParticleEmitterNode::onDeleteNotify(SimObject* obj)
{
	Parent::onDeleteNotify(obj);

	if(obj == (ShapeBase*)mMount)
	{
		mMount = NULL;
		mMountObject = -1;
		Con::executef(mDataBlock, 2, "onMountDeleted", scriptThis());
		deleteObject();
	}
}
//<- Dan

(Thanks to Pifford and Guimo for suggesting I just delete the object ;) and to Guimo for suggesting a script calback.)

packUpdate and unPackUpdate deal with transferring data between client and server (if I'm not very much mistaken). In packUpdatek, we write all the relevant data to a stream. The stream is sent to the client, where it is unpacked to the client object.
Find:

U32 retMask = Parent::packUpdate(con, mask, stream);

And add beneath:

//Dan's mods (mounting particles) ->
   if(stream->writeFlag(mask & InitialUpdateMask))
   {
	   if(stream->writeFlag(mMountObject != -1))
	   {
		   S32 gIndex = con->getGhostIndex(mMount);
		   if(stream->writeFlag(gIndex != -1))
		   {
			   stream->writeInt(gIndex,NetConnection::GhostIdBitSize);
			   stream->writeInt(mMountNode,ShapeBaseData::NumMountPointBits);
		   }
	   }
   }
   //<- Dan

Find:

Parent::unpackUpdate(con, stream);

And add beneath:

//Dan's mods (mounting particles) ->
   if(stream->readFlag())
   {
	   if(stream->readFlag())
	   {
		   if(stream->readFlag())
		   {
			   S32 gIndex = stream->readInt(NetConnection::GhostIdBitSize);
			   mMount = dynamic_cast<ShapeBase*>(con->resolveGhost(gIndex));
			   mMountNode = stream->readInt(ShapeBaseData::NumMountPointBits);
		   }
	   }
   }
   //<- Dan

That's it - it should build and compile. Here's an example of script usage - just put it in the console. I'm using sandard starter.fps art content here, just so you know.

new ParticleEmitterNode(){
   dataBlock = SteamEmitterNode;
   emitter = SteamEmitter;
   mountObject = LocalClientConnection.player;
   mountNode = 0;
};

If you don't specify a node, or if the node is for some reason unavailable, the emitter is mounted at the object's position.

Planned additions:
-Mounting using node names rather than mount numbers.
-Delete emitter when object is deleted.