Movie like camera system

Updates
2004-05-08 Had wrong code that didnt draw the camera sphere in the editor - added now

Description and background
While working on my current game project I felt the need for a little more spectacular camera system. My game is a little adventure game where one moves through various scenes and has to find items/solve puzzles/evade obstacles.

The camera system I wanted was something similar to LOTR:ROTK and other games - a very movie like camera where I could set up a camera to track the player from a fixed point. When the player moved into a new scene/area the camera then switched to that new scene.

I browsed through the resources and quickly found 2 resources that enabled me to easy accomplish this.

Resources needed
The 2 resources that needs to be put together are
Reactive Mission Regions and Using a Separate Camera Object

Add both resources to your engine/scripts and then follow my additions below.

What does this look like?
I made a small video (9 mb) that shows the system in use. I have a small tech demo level that contains 2 islands connected with a bridge (and some AI controlled sharks in the water). Within the level I added 5 mission regions. When the player enters either of these the camera switches to the center of the area and tracks the player. The height of the camera can be adjusted for each region. More on all this later after the movie

Camera demo movie (9 mb)

Showing mission regions in the world editor
To make it easier to create the regions we need to hack the editor to show the regions as well as the camera position.

In common/editor/EditorGui.cs find

%Mission_Item[5] = "Camera";

and add the line

%Mission_Item[6] = "MissionRegion";

and in objectBuilderGui.gui find

function ObjectBuilderGui::buildMissionArea(%this)
{
   %this.className = "MissionArea";
   %this.addField("area", "TypeRect", "Bounding area", "0 0 1024 1024");
   %this.process();
}

and add the block

function ObjectBuilderGui::buildMissionRegion(%this)
{
   %this.className = "MissionRegion";
   %this.addField("area", "TypeRect", "Bounding area", "0 0 20 20");
   %this.addField("cameraHeight", "TypeFloat", "Camera height", "100.0");
   %this.process();
}

Regions can now be created/edited/deleted in the world editor. I still need to figure out how to get them to draw with a box ingame, but this makes it a little easier

We need to add a console function to the engine, and then call that from the editor when selecting a worldregion. Here we go:

In the engine\editor\editTSCtrl.cc add this below the existing console functions:

ConsoleMethod( EditTSCtrl, renderBox, void, 3, 3, "(RectI area)")
{
   if(!object->mConsoleRendering)
      return;

   if(!object->mConsoleFrameColor.alpha)
      return;

   RectI area;
   dSscanf(argv[2], "%i %i %i %i", &area.point.x, &area.point.y, &area.extent.x, &area.extent.y);

   TerrainBlock * terrain = dynamic_cast<TerrainBlock*>(Sim::findObject("Terrain"));
   if(!terrain)
      return;

   GridSquare * gs = terrain->findSquare(TerrainBlock::BlockShift, Point2I(0,0));
   F32 height = F32(gs->maxHeight) * 0.03125f + 10.f;
      
   //
   Point2F min(area.point.x, area.point.y);
   Point2F max(area.point.x + area.extent.x, area.point.y + area.extent.y);

   glDisable(GL_CULL_FACE);
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   ColorI a(255,0,0,20);
   ColorI b(255,0,0,128);


   for(U32 i = 0; i < 2; i++)
   {
      //
      if(i){glColor4ub(a.red,a.green,a.blue,a.alpha);glBegin(GL_QUADS);} else {glColor4f(b.red,b.green,b.blue,b.alpha); glBegin(GL_LINE_LOOP);}
      glVertex3f(min.x, min.y, 0);
      glVertex3f(max.x, min.y, 0);
      glVertex3f(max.x, min.y, height);
      glVertex3f(min.x, min.y, height);
      glEnd();
   
      //
      if(i){glColor4ub(a.red,a.green,a.blue,a.alpha);glBegin(GL_QUADS);} else {glColor4f(b.red,b.green,b.blue,b.alpha); glBegin(GL_LINE_LOOP);}
      glVertex3f(min.x, max.y, 0);
      glVertex3f(max.x, max.y, 0);
      glVertex3f(max.x, max.y, height);
      glVertex3f(min.x, max.y, height);
      glEnd();
   
      //
      if(i){glColor4ub(a.red,a.green,a.blue,a.alpha);glBegin(GL_QUADS);} else {glColor4f(b.red,b.green,b.blue,b.alpha); glBegin(GL_LINE_LOOP);}
      glVertex3f(min.x, min.y, 0);
      glVertex3f(min.x, max.y, 0);
      glVertex3f(min.x, max.y, height);
      glVertex3f(min.x, min.y, height);
      glEnd();
   
      //
      if(i){glColor4ub(a.red,a.green,a.blue,a.alpha);glBegin(GL_QUADS);} else {glColor4f(b.red,b.green,b.blue,b.alpha); glBegin(GL_LINE_LOOP);}
      glVertex3f(max.x, min.y, 0);
      glVertex3f(max.x, max.y, 0);
      glVertex3f(max.x, max.y, height);
      glVertex3f(max.x, min.y, height);
      glEnd();
   }
   
   glDisable(GL_BLEND);
}

Recompile the engine

Now open common\editor\editorRender.cs and add this to the end of the file:

function MissionRegion::onEditorRender(%this, %editor, %selected, %expanded)
{
   %area = %this.getArea();

   if(%selected $= "true")
   {      
      // Region box
      %editor.renderBox(%area);
      // Region camera
      %dx = getWord(%area,2);
      %dy = getWord(%area,3);
      %x = getWord(%area,0) + %dx / 2;
      %y = getWord(%area,1) + %dy / 2;
      %z = %this.getCameraHeight();
      %editor.renderSphere(%x SPC %y SPC %z, 1, 1);
   }
}

Beware the wrapped lines in this forum - you should have no trouble spotting them, but here is a friendly reminder.

Its not perfect, as it would be nice to have a little handle like the other objects to drag/rotate/resize. But it all works as is.

Modifying the regions to save the camera height
I first started out with having a global setting for the camera height. But I soon realized that for most maps there would be a need for setting the height individually. I therefore modified the region code to save a height float for the camera.

In the missionArea.h code I added the cameraHeight float as well as a set/get method.

Find

private:
   typedef NetObject Parent;
   RectI             mArea;
  public:
   MissionRegion();

   static const MissionRegion * getServerObject();

   const RectI & getArea(){return(mArea);}
   void setArea(const RectI & area);

and change it to

private:
   typedef NetObject Parent;
   RectI             mArea;
   F32		     mCameraHeight;
  public:
   MissionRegion();

   static const MissionRegion * getServerObject();

   const RectI & getArea(){return(mArea);}
   void setArea(const RectI & area);

   const F32 getCameraHeight(){return(mCameraHeight);}
   void setCameraHeight(const F32 cameraHeight);

In the missionArea.cc change

MissionRegion::MissionRegion()
{
   mArea.set(Point2I(768, 768), Point2I(512, 512));
   mNetFlags.set(Ghostable | ScopeAlways);
}

to

MissionRegion::MissionRegion()
{
   mArea.set(Point2I(768, 768), Point2I(512, 512));
   mCameraHeight = 0;
   mNetFlags.set(Ghostable | ScopeAlways);
}

add this method:

void MissionRegion::setCameraHeight(const F32 cameraHeight)
{
   mCameraHeight = cameraHeight;// set it
   if( isServerObject() )
      mNetFlags.set(UpdateMask);// pass it along..
}

add this to the MissionRegion::onAdd() just before the return true;

setCameraHeight(mCameraHeight);

add this to the MissionRegion::initPersistFields() just before the endGroup("Dimensions");

addField("cameraHeight",  TypeF32,    Offset(mCameraHeight, MissionRegion));

Expose the get/set methods to the console by adding

ConsoleMethod( MissionRegion, getCameraHeight, F32, 2, 2, "()"
              "Returns 1 field: camera z")
{
   return object->getCameraHeight();
}

ConsoleMethod( MissionRegion, setCameraHeight, void, 3, 3, "(F32 z)")
{  
   F32 z = dAtoi(argv[2]);
   object->setCameraHeight(z);
}

and last but not least make sure we pack/unpack the cameraHeight by mdifying the unpackUpdate() and packUpdate() to include the cameraHeight variable like this:

void MissionRegion::unpackUpdate(NetConnection *, BitStream * stream)
{
   // ghost (initial) and regular updates share flag..
   if( stream->readFlag() ) {
      mathRead(*stream, &mArea);
	  stream->read(&mCameraHeight);
   }
}

U32 MissionRegion::packUpdate(NetConnection *, U32 mask, BitStream * stream)
{
   if( stream->writeFlag(mask & UpdateMask) ) {
      mathWrite(*stream, mArea);
	  stream->write(mCameraHeight);
   }
   return 0;
}

Phew - so far so good.

The separate camera object
There really are no changes to the camera code to make this work. Add the resource, compile and then its all ready to run.

Making the connection between player, region and camera
Tying it all together is quite simple.

Its all a matter of adding this code to the onEnterMissionRegion() function in the player.cs server script

function Armor::onEnterMissionRegion(%this,%obj,%rgn)
{   
   // Inform the client, if the client is a real player
   if (isObject(%obj.client.player)) {
      %obj.client.onEnterMissionRegion(%rgn);

      // Set camera for area
      if( %rgn && %obj.getDataBlock().getName() $= "PlayerBody") {
         %area = %rgn.getArea();
         %dx = getWord(%area,2);
         %dy = getWord(%area,3);
         %x = getWord(%area,0) + %dx / 2;
         %y = getWord(%area,1) + %dy / 2;
         %z = %rgn.getCameraHeight();
         %obj.client.trackCamera.setPosition(%x SPC %y SPC %z);
      }
   }
}

Seeing it all in effect
Now load up your favorite level in the mission editor. Add 2 mission regions that are next to each other and set the height of the camera for each. There is an orb that represents the camera, so you can easily see where its placed. In my code I set the x,y coordinates to be in the middle of the region.

Now go back to the game, press the tab button so you are using the tracking camera and then run back and forth between the 2 regions. Every time you enter the region the camera moves its position.

Done! :-)

Back to my story
Well - I quickly discovered that this camera system is not usable for platform games. It is damn hard to jump over my little bridge (as my video shows). But besides that it gives a very very nice feeling to the game, that is radically different from 1st and 3rd person views.

I will be using this system in my game for the areas where puzzles are to be solved and items to be found, but not where one needs to jump/evade things. There I'm moving the camera down to 3rd person again.

Nifty future enhancements
* It would be great to move the camera along a spline when the camera moves between regions - keeping its view on the player.

* Another thing I am thinking about is making the x,y coordinates setable too for a region and not only the height, as this would further enable one to make "more movie like" camera placement

* When the player leaves the region (and not enters a new) the camera should move itself to 3rd person behind the player (again along a spline or similar)

* Being able to set fov for a region - especially with the player very close to the camera

* If the player is far away from the camera, it could zoom in on the player automatically and zoom out again when he gets closer

And I bet there are tons of other things one could integrate into the system.

I hope I didnt forget to paste any code or explaination in here, and feel free to comment on this. The major credit for this should go to Cory Osborn and Mark Owen for their resources. I just put it together and added a link between the 2.