GameCamera: a third person, aiming camera (that works!)

...
         [b]ShapeBase* camera = connection->getCameraObject();[/b]
         while (m < numMoves)
         {
            [b]control->processTick(&movePtr[m]);

            // give camera a chance to look at movement
            if (camera != control)
                if (camera && camera->mProcessTick)
                   camera->processTick(&movePtr[m]);

            m++;[/b]
         }
         connection->clearMoves(m);

void ProcessList::advanceObjects()
{
   PROFILE_START(AdvanceObjects);

   // A little link list shuffling is done here to avoid problems
   // with objects being deleted from within the process method.
   GameBase list;
   GameBase* obj;
   
   list.plLinkBefore(head.mProcessLink.next);
   head.plUnlink();
   while ((obj = list.mProcessLink.next) != &list) {
      obj->plUnlink();
      obj->plLinkBefore(&head);

      // Each object is either advanced a single tick, or if it's
      // being controlled by a client, ticked once for each pending move.
      if (obj->mTypeMask & GameBaseObjectType) {

         GameBase *pGB = static_cast<GameBase *>(obj);
         GameConnection* con = pGB->getControllingClient();

         if (con && con->getControlObject() == pGB) {
            Move* movePtr;
            U32 m, numMoves;

            con->getMoveList(&movePtr, &numMoves);

            [b]ShapeBase* camera = con->getCameraObject();[/b]

            for (m = 0; m < numMoves && pGB->getControllingClient() == con; )
            {
               [b]obj->processTick(&movePtr[m]);

               // give camera a chance to look at movement
               if (camera != obj)
                   if (camera && camera->mProcessTick)
                      camera->processTick(&movePtr[m]);

               m++;[/b]
            }

            con->clearMoves(m);

            continue;
         }
      }
      [b]if (obj->mTypeMask & CameraObjectType ) {
         GameConnection* con = obj->getControllingClient();
         // if the current object is the active camera for it's client then it
         // will receive it's processTick along with the control object so we
         // can skip it here.
         if (con && con->getCameraObject() == obj)
            continue;
      }[/b]
      if (obj->mProcessTick)
         obj->processTick(0);
   }
   PROFILE_END();
}

// Modify muzzle if needed to aim at whatever is straight in front of eye.  Let the
// caller know if we actually modified the result.
bool ShapeBase::getCorrectedAim(const MatrixF& muzzleMat, VectorF* result)
{
   const F32 pullInD = 6.0;
   const F32 maxAdjD = 500;

   VectorF  aheadVec(0, maxAdjD, 0);

   MatrixF  eyeMat;
   Point3F  eyePos;

   [b]// Correct the aim based on where the camera is looking.
   // This only happens for the control object iff they are the camera
   // objects active target AND the camera is a GameCamera.
   bool set = false;
   if (GameConnection * gc = getControllingClient())
      if (!gc->isFirstPerson())
         if (gc->getControlObject() == this )   // only for the control object
            if (ShapeBase* camera = gc->getCameraObject())
               if (GameCamera* gameCamera = dynamic_cast<GameCamera *>(camera))
                  if (gameCamera->getTargetObject() == this)   // only for a game camera's target object
                  {
                     eyeMat = camera->getRenderTransform();
                     set = true;
                  }

   if (!set) {
      getEyeTransform(&eyeMat);
   }[/b]

   eyeMat.getColumn(3, &eyePos);
   eyeMat.mulV(aheadVec);
   Point3F  aheadPoint = (eyePos + aheadVec);

   ...

#include "math/mathUtils.h"
#include "sim/netObject.h"
[b]#include "game/gameCamera.h"[/b]

if (gc->isFirstPerson() && !gc->isAIControlled())

if ([b]/*gc->isFirstPerson() &&*/[/b] !gc->isAIControlled())

datablock GameCameraData(MyGameCameraData)
{
   lookAtOffset = "0 5 3";
   thirdPersonOffset = "0 -10 5";
   minLookAngle = -75;
   maxLookAngle = 89;
};

correctMuzzleVector = [b]true[/b];

// create advanced camera
   %this.advCamera = new GameCamera() {
      dataBlock = MyGameCameraData;
   };

   MissionCleanup.add(%this.advCamera);
   %this.advCamera.scopeToClient(%this);

%this.setControlObject(%this.player);
   %this.setCameraObject(%this.advCamera);
   %this.advCamera.setTargetObject(%player);
   %this.setFirstPerson(false);

...
   if(bool(mTargetObject)) {
      mTargetAsPlayer = dynamic_cast<Player*>(obj);
		processAfter(mTargetObject);
		deleteNotify(mTargetObject);
	}
   [b]if (bool(mTargetAsPlayer)) {
      PlayerData* pDB = dynamic_cast<PlayerData*>(mTargetAsPlayer->getDataBlock());
      if (bool(pDB)) {
         mMinLookAngle = pDB->minLookAngle;
         mMaxLookAngle = pDB->maxLookAngle;
      }
   } else {
      mMinLookAngle = mDataBlock->minLookAngle;
      mMaxLookAngle = mDataBlock->maxLookAngle;
   }[/b]
}

...
   // set the player's head pitch
   //if (mTargetAsPlayer)
   //{
   //   mTargetAsPlayer->getHeadRotation().x = mPitch;
   //}
   ...

Quote:
In GameProcess.cc ProcessList::advanceClientTime() make these changes:

...
         ShapeBase* camera = connection->getCameraObject();
         while (m < numMoves)
         {
            control->processTick(&movePtr[m++]);

            // give camera a chance to look at movement
            if (camera && camera->mProcessTick)
               camera->processTick(&movePtr[m]);
         }
         connection->clearMoves(m);

ShapeBase* camera = connection->getCameraObject();

ShapeBase* camera = connection->getCameraObject();

void GuiCrossHairHud::onRender(Point2I offset, const RectI &updateRect)
{
   // Must have a connection and player control object
   GameConnection* conn = GameConnection::getConnectionToServer();
   if (!conn)
      return;
   ShapeBase* control = conn->getControlObject();
   if (!control || !(control->getType() & ObjectMask) [b]/*|| !conn->isFirstPerson()*/[/b])
      return;

moveMap.bind( mouse, yaxis, pitch );