Torque networking, applied to VOIP

if(!mSendingEvents)
   {
	  if (!theEvent->mRefCount) 
		delete theEvent;
      return false;
   }

#ifndef _VOXEVENT_H_
#define _VOXEVENT_H_

#include "vox.h"
#include <sim/netConnection.h>


class VoxEvent : public NetEvent
{
	typedef NetEvent Parent;	
	char *speexData;
	int numBits;

public:
	VoxEvent(char *data = NULL, int bitCount = 0);
	~VoxEvent();

	int getNumBits() { return numBits; };
	const char *getSpeexData() { return speexData; };
	
	void pack(NetConnection *conn, BitStream *bstream);
	void write(NetConnection *conn, BitStream *bstream);
	void unpack(NetConnection *conn, BitStream *bstream);
	void process(NetConnection *conn);

	DECLARE_CONOBJECT(VoxEvent);
};

#endif

#include "voxEvent.h"

#include "core/bitStream.h"
#include "sim/sceneObject.h"

#include "game/gameConnection.h"

IMPLEMENT_CO_NETEVENT_V1(VoxEvent);

VoxEvent::VoxEvent(char *data, int nBits) 
{	
	mGuaranteeType = Unguaranteed; // no sweat if lost

	if (data == NULL || nBits <= 0) {
		speexData = NULL;
		numBits = 0; 
	} else {
		int nBytes = 1 + (nBits >> 3);
		speexData = new char[nBytes];
		numBits = nBits;
		dMemcpy(speexData, data, nBytes);
	}
}

VoxEvent::~VoxEvent() 
{
	if (speexData != NULL) {
		delete [] speexData;
		speexData = NULL;
	}
}


void 
VoxEvent::write(NetConnection *conn, BitStream * b) 
{
	pack(conn, b);
}


void 
VoxEvent::pack(NetConnection *conn, BitStream * b) 
{	
	b->writeInt(numBits, 16);
	b->writeBits(numBits, speexData);
}


void 
VoxEvent::unpack(NetConnection *conn, BitStream * b) 
{
	numBits = b->readInt(16);
	int nBytes = 1 + (numBits / 8);	
	speexData = new char[nBytes];
	b->readBits(numBits, speexData);
}


void 
VoxEvent::process(NetConnection *conn) 
{ 
	GameConnection *sourceCon = (GameConnection*)conn; 

	// if we are on the client side. 
	if (sourceCon->isConnectionToServer()) { 
		// TODO: play sound 
		//Con::printf("we received voxEvent as client\n");

	} else {  // if we are on the server side, relay it to nearby clients
		ShapeBase *sourceCamera = sourceCon->getCameraObject(); 
		if(!sourceCamera) {
			Con::errorf("server received voxEvent from client who has no camera\n");
			return; 
		}
		Point3F sourcePos = sourceCamera->getTransform().getPosition(); 

		F32 maxVoxDistanceSquared = Vox::getExtremeAudibleRange() * Vox::getExtremeAudibleRange();

		for (SimSetIterator it(Sim::getClientGroup()); *it; ++it) { 
			GameConnection *gc = dynamic_cast<GameConnection*>(*it); 

			if (gc == NULL)  {
				Con::errorf("server found a NULL GameConnection\n");
				continue;
			}
			
			if (gc == sourceCon) {
				//Con::printf("server will not relay VoxEvent back to its sender\n");
				continue; 
			}

			GameBase *clientCamera = gc->getCameraObject(); 
			Point3F clientPos = clientCamera->getTransform().getPosition(); 

			F32 distSquared = (clientPos - sourcePos).lenSquared();
			
			if (distSquared <= maxVoxDistanceSquared) { 
				//Con::printf("server relaying voxEvent over distance %f\n", mSqrt(distSquared));
				gc->postNetEvent(this); // NetEvents are reference counted, so this is sane
			} else {
				//Con::printf("not relaying a voxEvent over a distance of %f > %f\n", mSqrt(distSquared), Vox::getExtremeAudibleRange());
			}
		} 
	} 
}

Quote:
The datablock-centric nature of TGE objects continues to baffle me.