Commander Map

//Returns the ID of the current Player
function getClientPlayerId(){
 for (%c = 0; %c<ServerConnection.getCount(); %c++)
 { 
   %obj = ServerConnection.getObject(%c);
   if (%obj.getClassName() $= "AIPlayer")
   { 
     %name = StripMLControlChars(%obj.getShapeName());
	
     if (%name $= $Pref::Player::Name)
     {
       return %obj.getId();
     }
   }
  }
 return -1;
}

MapHud.zoomTo(0.5);
function panPlayer() { 
	if($PlayerID $=""){
		$PlayerID = getClientPlayerId();
	}
	if($PlayerID $="-1"){
		MapHud.setVisible(0);
		return;
	}
	
	MapHud.panTo(getWord($PlayerID.getPosition(), 0), getWord($PlayerID.getPosition(), 1)); 
	schedule(100, 0, panPlayer); 
}

panplayer();

//-----------------------------------------------------------------------------
// Commander Map HUD
//
// Portions Copyright (c) GarageGames.Com
// Copyright (c) Ben Garney
// Convert into TSE by Shannon Scarvaci
//-----------------------------------------------------------------------------

#include "atlas/atlasInstance.h"
#include "atlas/atlasInstanceEntry.h"
// These includes are probably overkill -- BJG
#include "platform/platform.h"
#include "platform/platformVideo.h"
#include "platform/platformAudio.h"
#include "platform/platformInput.h"
#include "core/findMatch.h"

//#include "dgl/dgl.h"
#include "game/game.h"
#include "math/mMath.h"
#include "console/simBase.h"
#include "console/console.h"
//#include "terrain/terrData.h"
//#include "terrain/terrRender.h"
//#include "terrain/waterBlock.h"
#include "game/collisionTest.h"
#include "game/showTSShape.h"
#include "sceneGraph/sceneGraph.h"
#include "gui/core/guiTSControl.h"
#include "game/moveManager.h"
#include "console/consoleTypes.h"
#include "game/shapeBase.h"
#include "core/dnet.h"
#include "game/gameConnection.h"
#include "core/fileStream.h"
#include "gui/core/guiCanvas.h"
//#include "dgl/gTexManager.h"
#include "sceneGraph/sceneLighting.h"
#include "terrain/sky.h"
#include "game/ambientAudioManager.h"
#include "core/frameAllocator.h"
#include "sceneGraph/detailManager.h"
#include "gui/controls/guiMLTextCtrl.h"
#include "platform/profiler.h"
#include "game/fx/underLava.h"

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

class GuiCommanderHud : public GuiTSCtrl
{
private:
   typedef GuiTSCtrl Parent;


   Point2F mPanSpeed;
   F32     mZoomSpeed;
   S32     mLastRenderTime;

public:
   Point2F mPanGoal, mCurPan;
   F32     mZoomGoal, mCurZoom;

   GuiCommanderHud();

   bool processCameraQuery(CameraQuery *query);
   void renderWorld(const RectI &updateRect);

   void onRender( Point2I, const RectI &);
   static void initPersistFields();

   DECLARE_CONOBJECT( GuiCommanderHud );
};


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

IMPLEMENT_CONOBJECT( GuiCommanderHud );

GuiCommanderHud::GuiCommanderHud()
:   mPanSpeed(10, 10), mZoomSpeed(1), mCurPan(0,0), mCurZoom(M_PI_F/2),
    mPanGoal(0,0), mZoomGoal(M_PI_F/2), mLastRenderTime(0)
{
}

void GuiCommanderHud::initPersistFields()
{
   Parent::initPersistFields();

   addField("panSpeed",  TypePoint2F, Offset(mPanSpeed,  GuiCommanderHud), "Set the speed (x/y) we pan to our goal.");
   addField("zoomSpeed", TypeF32,     Offset(mZoomSpeed, GuiCommanderHud), "Set the speed we zoom with to our goal.");
}

static void findObjectsCallback(SceneObject* obj, void * val)
{
   Vector<SceneObject*> * list = (Vector<SceneObject*>*)val;
   list->push_back(obj);
}

bool GuiCommanderHud::processCameraQuery(CameraQuery *q)
{
   // draw all the objects
   Vector<SceneObject*> objects;
   U32 mask = AtlasObjectType;
   gClientContainer.findObjects(mask, findObjectsCallback, &objects);
	 Box3F box;
	 Point3F pt;
   for(U32 i = 0; i < objects.size(); i++)
   {
      // get the color
		 if(objects[i]->getTypeMask() & AtlasObjectType) {
			 pt = objects[i]->getBoxCenter();
			 box = objects[i]->getWorldBox();
			 break;
		 }
	 }
   // Scale ranges based on the highest/lowest point in the terrain
   F32 maxHi = box.max.x/2;//gClientSceneGraph->getCurrentTerrain()->findSquare(8, 0,0)->maxHeight / 10;
   F32 minHi = box.min.x/2;//gClientSceneGraph->getCurrentTerrain()->findSquare(8, 0,0)->minHeight / 10;

   q->object = NULL;
	 q->nearPlane = maxHi - box.max.z;
	 q->farPlane = box.len_z() + q->nearPlane + 100;
   //q->nearPlane = 1;
   //q->farPlane  = mFabs(maxHi) + mFabs(minHi);
   q->fov       = mCurZoom;

   // Make us high up, facing straight down.
   q->cameraMatrix = MatrixF(EulerF(3.14/2, 0, 0)); // rotate us to look straight down
   q->cameraMatrix.setPosition(Point3F(mCurPan.x+pt.x,mCurPan.y+pt.y, maxHi + 100)); // and high enough we won't clip

   return true;
}

void GuiCommanderHud::renderWorld(const RectI &updateRect)
{
   // Set up state
   // draw all the objects
   Vector<SceneObject*> objects;
   U32 mask = AtlasObjectType;
   gClientContainer.findObjects(mask, findObjectsCallback, &objects);
	 Box3F box;
	 Point3F pt;
   for(U32 i = 0; i < objects.size(); i++)
   {
      // get the color
		 if(objects[i]->getTypeMask() & AtlasObjectType) {
			 pt = objects[i]->getBoxCenter();
			 box = objects[i]->getWorldBox();
			 break;
		 }
	 }
   //TerrainRender::mRenderingCommander = true;
   F32 oldVisDist = gClientSceneGraph->getVisibleDistance();
   gClientSceneGraph->setVisibleDistance(box.len_x());
   F32 oldFogDist = gClientSceneGraph->getFogDistance();
   gClientSceneGraph->setFogDistance(box.len_x());

   // set up the camera and viewport stuff:

   // Render (stolen from GameRenderWorld)
   PROFILE_START(GameRenderCommanderWorld);
   FrameAllocator::setWaterMark(0);

#if defined(GATHER_METRICS) && GATHER_METRICS > 1
   TextureManager::smTextureCacheMisses = 0;
#endif

   /*glEnable(GL_DEPTH_TEST);
   glDepthFunc(GL_LEQUAL);
   glClear(GL_DEPTH_BUFFER_BIT);
   glDisable(GL_CULL_FACE);
   glMatrixMode(GL_MODELVIEW);*/
	 GFX->setZEnable(true);
	 GFX->setZFunc(GFXCmpLessEqual);
   GFX->clear( GFXClearZBuffer | GFXClearStencil | GFXClearTarget, ColorI(0,0,0), 1.0f, 0 );
	 GFX->setCullMode(GFXCullNone);
   //dglSetCanonicalState();
   // If you want to render other things, change this mask.
   gClientSceneGraph->renderScene(  StaticObjectType | VehicleObjectType |  EnvironmentObjectType | AtlasObjectType | InteriorObjectType | WaterObjectType );
	 GFX->setZEnable(false);
   //glDisable(GL_DEPTH_TEST);

#if defined(GATHER_METRICS) && GATHER_METRICS > 1
   Con::setFloatVariable("Video::texResidentPercentage",
                         TextureManager::getResidentFraction());
   Con::setIntVariable("Video::textureCacheMisses",
                       TextureManager::smTextureCacheMisses);
#endif

   AssertFatal(FrameAllocator::getWaterMark() == 0, "Error, someone didn't reset the water mark on the frame allocator!");
   FrameAllocator::setWaterMark(0);
   PROFILE_END();


   // Restore state
   gClientSceneGraph->setVisibleDistance(oldVisDist);
   gClientSceneGraph->setFogDistance    (oldFogDist);
   //TerrainRender::mRenderingCommander = false;

   GFX->setClipRect( updateRect);//dglSetClipRect(updateRect);
}

void GuiCommanderHud::onRender(Point2I offset, const RectI &updateRect)
{
   // Update pan/zoom
   S32 time = Platform::getVirtualMilliseconds();
   S32 dt = time - mLastRenderTime;
   mLastRenderTime = time;

   mCurPan  += (mPanGoal  - mCurPan)  * (F32)dt/1000.f;
   mCurZoom += (mZoomGoal - mCurZoom) * (F32)dt/1000.f;

   // Render the world...
   Parent::onRender(offset, updateRect);

   // If you wanted to render custom GUI elements, like a sensor map, icons for
   // players/vehicles/objectives, you would do it here by calling project()
   // for all their positions and drawing bitmaps at the appropriate locations.
}

ConsoleMethod(GuiCommanderHud, pan, void, 4, 4, "(x, y) Cut to a location.")
{
   object->mPanGoal.set(dAtof(argv[2]), dAtof(argv[3]));
   object->mCurPan.set (dAtof(argv[2]), dAtof(argv[3]));
}

ConsoleMethod(GuiCommanderHud, panTo, void, 4, 4, "(x, y) Smoothly pan to a location.")
{
   object->mPanGoal.set(dAtof(argv[2]), dAtof(argv[3]));
}

ConsoleMethod(GuiCommanderHud, zoom, void, 3, 3, "(val) Zoom to a specified level.")
{
   object->mZoomGoal = dAtof(argv[2]);
   object->mCurZoom  = dAtof(argv[2]);
}

ConsoleMethod(GuiCommanderHud, zoomTo, void, 3, 3, "(val) Smoothly zoom to a specified level.")
{
   object->mZoomGoal = dAtof(argv[2]);
}

ConsoleMethod(GuiCommanderHud, zoomToArea, void, 6, 7, "(top, left, right, bottom, bool cut) Smoothly zoom to view the specified area. If cut is set, we jump there.")
{
   // Parse arguments
   F32 top, left, right, bottom;

   top    = dAtof(argv[2]);
   left   = dAtof(argv[3]);
   right  = dAtof(argv[4]);
   bottom = dAtof(argv[5]);

   // Figure out the center of the area
   Point2F center;

   center.x = (left + right) * 0.5f;
   center.y = (top + bottom) * 0.5f;

   object->mZoomGoal = mFabs(left - right) / 200; // Cheesy scaling fakery.

   // And set our motion
   object->mPanGoal = center;

   // Cut if requested
   if(argc > 6)
      if(dAtob(argv[6]))
      {
         object->mCurPan  = object->mPanGoal;
         object->mCurZoom = object->mZoomGoal;
      }
}

GameConnection* conn = GameConnection::getConnectionToServer();
for (SimSetIterator itr(conn); *itr; ++itr) {
  // Make sure the shapebase object is a Vehicle object.
  if ((*itr)->getType() & VehicleObjectType) {
	ShapeBase* shape = static_cast<ShapeBase*>(*itr);
	Point3F pos = shape->getPosition();
	Point3F newCoord;
	if (!project(pos, &newCoord)){
	  Con::printf("CodeLog----:Projection Error.  pos: x=%f y=%f z=%f",pos.x,pos.y,pos.z);
        }
	//else draw an icon at newCoord...
  }
}