GuiRadarCtrl and GuiRadarTSCtrl port for T3D

//-----------------------------------------------------------------------------
// Torque Game Engine Advanced v1.0
// Copyright (C) GarageGames.com, Inc.
// Convertion to TGEA 1.8.1 with karakurty
//-----------------------------------------------------------------------------
#include "platform/platform.h"

#include "gui/core/guiControl.h"
#include "gfx/gfxDrawUtil.h"
#include "T3D/player.h"

#include "console/console.h"
#include "console/consoleTypes.h"
#include "gfx/gfxDevice.h"
#include "app/game.h"
#include "T3D/gameConnection.h"
#include "T3D/ShapeBase.h"
#include "gfx/primBuilder.h"

#include "gui/controls/GuiRadarCtrl.h"

IMPLEMENT_CONOBJECT(GuiRadarCtrl);

GuiRadarCtrl::GuiRadarCtrl(void)
{
	// Radar Background default
	mRadarBitmapName = StringTable->insert("art/gui/compass_map_radar/radar_base.png");

	// Blip defaults
	mBlipUpName = StringTable->insert("art/gui/compass_map_radar/dot_teal.png");
	mBlipBelowName = StringTable->insert("art/gui/compass_map_radar/dot_black.png");
	mBlipLevelName = StringTable->insert("art/gui/compass_map_radar/dot_red.png");
	mShowRadar = true;
	//mRadarWrap = false;
	mRadarRadiusRange = 100.0f;

	mLevelRange = 20.0f;

	// As default show only players
	mShowShapeBase = false;
	mShowVehicles = false;
	mShowPlayers = true;
    mShowBots = true;

	// Compass defaults
	mCompassBitmapName = StringTable->insert("art/gui/compass_map_radar/compass.png");
	mShowCompass = true;

	mCompassRotation = 0.0f;

	// <MH>
	// Map defaults
	mMapBitmapName = StringTable->insert("art/gui/compass_map_radar/scorchedPlanet.png");
	mShowMap = true;
	// </MH>

	mHideAll = false;
}


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

    addGroup("Radar");
    addField("RadarBitmap",		TypeFilename,	  Offset(mRadarBitmapName,    GuiRadarCtrl));
    //addField("RadarWrap",		TypeBool,		  Offset(mRadarWrap,          GuiRadarCtrl));
    addField("blip_above",		TypeFilename,     Offset(mBlipUpName,         GuiRadarCtrl));
	addField("blip_below",		TypeFilename,     Offset(mBlipBelowName,      GuiRadarCtrl));
	addField("blip_level",		TypeFilename,     Offset(mBlipLevelName,      GuiRadarCtrl));
	addField("RadarRange",		TypeF32,		  Offset(mRadarRadiusRange,   GuiRadarCtrl));
	addField("ShowRadar",		TypeBool,		  Offset(mShowRadar,          GuiRadarCtrl));
	endGroup("Radar");
   
	addGroup("Compass");
	addField("CompassBitmap",	TypeFilename,	Offset(mCompassBitmapName, GuiRadarCtrl));
	addField("ShowCompass",		TypeBool,		Offset(mShowCompass,       GuiRadarCtrl),"Show Compass)");
    endGroup("Compass");		

	// <MH>
	addGroup("Map");
	addField("MapBitmap",		TypeFilename,	Offset(mMapBitmapName,    GuiRadarCtrl));
	addField("ShowMap",			TypeBool,		Offset(mShowMap,		  GuiRadarCtrl), "Show Map");
    endGroup("Map");	
	// </MH>
	
	addGroup("Misc");
	addField("RadarShowPlayers",	TypeBool,     Offset(mShowPlayers,     GuiRadarCtrl),"Show Players on Radar");
	addField("RadarShowVehicles",	TypeBool,     Offset(mShowVehicles,    GuiRadarCtrl),"Show Vehicles on Radar");
    addField("RadarShowBots",		TypeBool,     Offset(mShowBots,        GuiRadarCtrl),"Show Bots on Radar");
	addField("RadarShowShapeBase",	TypeBool,     Offset(mShowShapeBase,   GuiRadarCtrl),"Show All ShapeBase derived objects on Radar");
	addField("LevelRange",			TypeS32,      Offset(mLevelRange,      GuiRadarCtrl),"The height difference at which the Level blip is displayed");
	addField("HideAll",				TypeBool,     Offset(mHideAll,         GuiRadarCtrl));
	addField("ShowFrame",			TypeBool,     Offset(mShowFrame,       GuiRadarCtrl));
	endGroup("Misc");
}

ConsoleMethod( GuiRadarCtrl, setValue, void, 4, 4, "(int xAxis, int yAxis)"
              "Set the offset of the bitmap.")
{
	object->setValue(dAtoi(argv[2]), dAtoi(argv[3]));
}

ConsoleMethod( GuiRadarCtrl, setRadarBitmap, void, 3, 4, "(string filename, bool resize=false)"
               "Set the bitmap displayed in the control. Note that it is limited in size, to 256x256.")
{
   char fileName[1024];
   Con::expandScriptFilename(fileName, sizeof(fileName), argv[2]);
   object->setRadarBitmap(fileName, argc > 3 ? dAtob( argv[3] ) : false );
}

ConsoleMethod( GuiRadarCtrl, setRadarRange, void, 3, 3, "")
{
	Con::printf("Object->SetRadius = %f", dAtof(argv[2]));
	object->setRadius(dAtof(argv[2]));
}

bool GuiRadarCtrl::onWake()
{
   if (! Parent::onWake())
      return false;
   
	setActive(true);
    setRadarBitmap(mRadarBitmapName);
	setRadarUpBlipBitmap(mBlipUpName);
	setRadarBelowBlipBitmap(mBlipBelowName);
	setRadarLevelBlipBitmap(mBlipLevelName);
	setRadius(mRadarRadiusRange);
	setLevelRange(mLevelRange);
	setCompassBitmap(mCompassBitmapName);
	setMapBitmap(mMapBitmapName);

   return true;
}

void GuiRadarCtrl::onSleep()
{
    //Parent::onSleep();

    mRadarTextureObject = NULL;
	mRadarDot = NULL;
	mRadarUp = NULL;
	mRadarDown = NULL;

	mCompassTextureObject = NULL;
	mMapTextureObject = NULL;

    Parent::onSleep();
}

//-------------------------------------
void GuiRadarCtrl::inspectPostApply()
{
   // if the extent is set to (0,0) in the gui editor and appy hit, this control will
   // set it's extent to be exactly the size of the bitmap (if present)
   Parent::inspectPostApply();

   if ((getExtent().y == 0) && (getExtent().x == 0) && mRadarTextureObject)
   {
	   setExtent(mRadarTextureObject->getWidth(), mRadarTextureObject->getHeight());
   }

   if ((getExtent().y == 0) && (getExtent().x == 0) && mCompassTextureObject)
   {
	   //setExtent(mCompassTextureObject->getWidth(), mCompassTextureObject->getHeight());
   	   setExtent(mRadarTextureObject->getWidth(), mRadarTextureObject->getHeight());
   }

}

void GuiRadarCtrl::setRadarBitmap(const char *name, bool resize)
{
   mRadarBitmapName = StringTable->insert(name);
   if (*mRadarBitmapName)
	{
		mRadarTextureObject.set( mRadarBitmapName, &GFXDefaultGUIProfile, avar("%s() - mRadarTextureObject (line %d)", __FUNCTION__, __LINE__) );

      // Resize the control to fit the bitmap
      if( mRadarTextureObject && resize )
      {
	     setExtent(mRadarTextureObject->getWidth(), mRadarTextureObject->getHeight());
         updateSizing();

      }
   }
   else
      mRadarTextureObject = NULL;

   setUpdate();
}

void GuiRadarCtrl::setRadarLevelBlipBitmap(const char *name)
{
   mBlipLevelName = StringTable->insert(name);
   if (*mBlipLevelName)
		mRadarDot.set( mBlipLevelName, &GFXDefaultGUIProfile, avar("%s() - mRadarDot (line %d)", __FUNCTION__, __LINE__) );
   else
      mRadarDot = NULL;

   setUpdate();
}

void GuiRadarCtrl::setRadarUpBlipBitmap(const char *name)
{

   mBlipUpName = StringTable->insert(name);
   if (*mBlipUpName)
		mRadarUp.set( mBlipUpName, &GFXDefaultGUIProfile, avar("%s() - mRadarUp (line %d)", __FUNCTION__, __LINE__) );
   else
      mRadarUp = NULL;

   setUpdate();

}

void GuiRadarCtrl::setRadarBelowBlipBitmap(const char *name)
{

   mBlipBelowName = StringTable->insert(name);
   if (*mBlipBelowName)
		mRadarDown.set( mBlipBelowName, &GFXDefaultGUIProfile, avar("%s() - mRadarDown (line %d)", __FUNCTION__, __LINE__) );
   else
      mRadarDown = NULL;

   setUpdate();
}

void GuiRadarCtrl::setCompassBitmap(const char *name, bool resize)
{
   mCompassBitmapName = StringTable->insert(name);
   if (*mCompassBitmapName)
	{
		mCompassTextureObject.set( mCompassBitmapName, &GFXDefaultGUIProfile, avar("%s() - mCompassTextureObject (line %d)", __FUNCTION__, __LINE__) );

      // Resize the control to fit the bitmap
      if( mCompassTextureObject && resize )
      {
		 setExtent(mCompassTextureObject->getWidth(), mCompassTextureObject->getHeight());
         updateSizing();
      }
   }
   else
      mCompassTextureObject = NULL;

   setUpdate();
}

// <MH>
void GuiRadarCtrl::setMapBitmap(const char *name)
{
   mMapBitmapName = StringTable->insert(name);

   if (*mMapBitmapName)
		mMapTextureObject.set( mMapBitmapName, &GFXDefaultGUIProfile, avar("%s() - mMapTextureObject (line %d)", __FUNCTION__, __LINE__) );
   else
      mMapTextureObject = NULL;

   setUpdate();
}
// </MH>

void GuiRadarCtrl::setRadius(const F32 newRange)
{
	mRadarRadiusRange = newRange;
}

void GuiRadarCtrl::setLevelRange(const F32 newLevelRange)
{
	mLevelRange = newLevelRange;
}

void GuiRadarCtrl::setCompassRotation(const F32 rotation)
{
	mCompassRotation = rotation;
}

ConsoleMethod( GuiRadarCtrl, setCompassRotation, void, 3, 3, "")
{
	Con::printf("Object->SetRadius = %f", dAtof(argv[2]));
	object->setCompassRotation(dAtof(argv[2]));
}

float Vector3dToDegree(Point3F vector)
{
    float angle;
	if (vector.x == 0.0F)
    {
        if (vector.y > 0.0F)
            return 0.0F;
        else if (vector.y == 0.0F)
            return -1.0F;
        else
            return 180.0F;
    }
    if (vector.y == 0.0F)
    {
        if (vector.x < 0.0F)
            return 270.0F;
        else
            return 90.0F;
    }
    angle = atanf((vector.x) / (-vector.y)) * (180.0F / M_PI);
    if ((-vector.y) < 0.0F)
        return angle + 180.0F;
    else
    {
        if (vector.x > 0.0F)
            return angle;
        else
            return angle + 360.0F;
    }
}

// Conversion function, Degrees to vector (used after manipulating camera angle to represent angle of object on radar)
void DegreeToVector2d(float angle, float length, Point3F &vector)
{
	angle = (angle / 180.0F) * M_PI;
    vector.x = length * (sin(angle) );
	vector.y = length * (-cos(angle) );
}

void GuiRadarCtrl::onRender(Point2I offset, const RectI &updateRect)
{
	// Must have a connection
	GameConnection* conn = GameConnection::getConnectionToServer();
	if (!conn) return;
	// Must have controlled object
	GameBase* control = conn->getControlObject();
	if (!control) return;

	//Find distance from top-left corner to center of radar image 
	Point2F center(getExtent().x / 2, getExtent().y / 2); 

	F32 HW = getExtent().y / 2.0;

	//Make center the UI object's coordinate center 
	center.x += getBounds().point.x; 
	center.y += getBounds().point.y; 


    MatrixF cam;
	VectorF camDir;
	Point3F cameraRot;

    conn->getControlCameraTransform(0,&cam);	// store camera information
    cam.getColumn(3, &mMyCoords);				// get camera position
    cam.getColumn(1, &camDir);					// get camera vector
	cam.getRow(1,&cameraRot);					// get camera rotation

	// Remove Rotation around the X/Y axis
	//cameraRot.x = 0;
	//cameraRot.y = 0;
	
	cameraRot.neg();							// bug forces us to need to invert camera rotation angle

	// get angle that camera is facing
	float cameraAngle = Vector3dToDegree(cameraRot);

	if (mMapTextureObject && mShowMap)
    {
		GFX->getDrawUtil()->clearBitmapModulation();

        GFXTextureObject* texture = mMapTextureObject;

        setupStateBlocks();
        GFX->setStateBlock(mBeforeStateBlock);

		GFX->setTexture( 0, texture );
        GFX->disableShaders();
		
    	F32 width = getBounds().extent.x * 0.5;

		MatrixF rotMatrix(EulerF(0.0, 0.0, mDegToRad(cameraAngle)));

//		Point3F offset(offset.x + mBounds.extent.x / 2, offset.y + mBounds.extent.y / 2, 0.0);
		Point3F offset( offset.x + getBounds().extent.x / 2, offset.y + getBounds().extent.y / 2, 0.0);

		// The 8 will help model the scale of which the player moves across the map
		Point2F offsetTexture(mMyCoords.x / ((float)mMapTextureObject->getBitmapWidth() * 8), 
							 -mMyCoords.y / ((float)mMapTextureObject->getBitmapHeight() * 8));

//		F32 uvOffset = (float)mBounds.extent.x / (float)mMapTextureObject->getBitmapWidth() / 2;
		F32 uvOffset = (float)getBounds().extent.x / (float)mMapTextureObject->getBitmapWidth() / 2;

		// Octagons Vertices
		Point3F points[10];
		points[0] = Point3F(0.0f, 0.0f, 0.0f);
		points[1] = Point3F(0.0f, width, 0.0f);
		points[2] = Point3F(width * 0.7f, width * 0.7f, 0.0f);
		points[3] = Point3F(width, 0.0f, 0.0f);
		points[4] = Point3F(width * 0.7f, -width * 0.7f, 0.0f);
		points[5] = Point3F(0.0f, -width, 0.0f);
		points[6] = Point3F(-width * 0.7f, -width * 0.7f, 0.0f);
		points[7] = Point3F(-width, 0.0f, 0.0f);
		points[8] = Point3F(-width * 0.7f, width * 0.7f, 0.0f);
		points[9] = Point3F(0.0f, width, 0.0f);

		for (int i = 0; i < 10; i++)
		{
			rotMatrix.mulP(points[i]);
			points[i] += offset;
		}

		PrimBuild::color3f(1.0f, 1.0f, 1.0f);

		PrimBuild::begin(GFXTriangleFan, 10);
		PrimBuild::texCoord2f(offsetTexture.x + 0.0f, offsetTexture.y + 0.0f);
		PrimBuild::vertex3fv(points[0]);
		PrimBuild::texCoord2f(offsetTexture.x + 0.0f, offsetTexture.y + uvOffset);
		PrimBuild::vertex3fv(points[1]);
		PrimBuild::texCoord2f(offsetTexture.x + uvOffset * 0.7f, offsetTexture.y + uvOffset * 0.7f);
		PrimBuild::vertex3fv(points[2]);
		PrimBuild::texCoord2f(offsetTexture.x + uvOffset, offsetTexture.y + 0.0f);
		PrimBuild::vertex3fv(points[3]);
		PrimBuild::texCoord2f(offsetTexture.x + uvOffset * 0.7f, offsetTexture.y + -uvOffset * 0.7f);
		PrimBuild::vertex3fv(points[4]);
		PrimBuild::texCoord2f(offsetTexture.x + 0.0f, offsetTexture.y + -uvOffset);
		PrimBuild::vertex3fv(points[5]);
		PrimBuild::texCoord2f(offsetTexture.x + -uvOffset * 0.7f, offsetTexture.y + -uvOffset * 0.7f);
		PrimBuild::vertex3fv(points[6]);
		PrimBuild::texCoord2f(offsetTexture.x + -uvOffset, offsetTexture.y + 0.0f);
		PrimBuild::vertex3fv(points[7]);
		PrimBuild::texCoord2f(offsetTexture.x + -uvOffset * 0.7f, offsetTexture.y + uvOffset * 0.7f);
		PrimBuild::vertex3fv(points[8]);
		PrimBuild::texCoord2f(offsetTexture.x + 0.0f, offsetTexture.y + uvOffset);
		PrimBuild::vertex3fv(points[9]);
		PrimBuild::end();


		GFX->setStateBlock(mBlendDisabledStateBlock);
	}

	if (mRadarTextureObject && mShowRadar)
    {
        GFX->getDrawUtil()->clearBitmapModulation();

        RectI rect(offset, getExtent());
        GFX->getDrawUtil()->drawBitmapStretch(mRadarTextureObject, rect);
    }

	GFX->getDrawUtil()->clearBitmapModulation();

	GFXTextureObject* LevelBlip = (GFXTextureObject*) mRadarDot;
	GFXTextureObject* HighBlip = (GFXTextureObject*) mRadarUp;
	GFXTextureObject* LowBlip = (GFXTextureObject*) mRadarDown;	

	// Go through all ghosted objects on connection (client-side)
	for (SimSetIterator itr(conn); *itr; ++itr) {
      // Make sure that the object is a ShapeBase object
      if ((*itr)->getType() & ShapeBaseObjectType) {
         ShapeBase* shape = static_cast<ShapeBase*>(*itr);
		 // Make sure that the object isn't the client
		 if (shape != control  && shape->getShapeName()) { 
			// Make sure the ShapeBase object is a player

			 if (shape->getType()) {
					
				   //ONly check when ShapeBase is not selecting, we are after all iterating through ShapeBaseObjects
					if (!mShowShapeBase)
					{
						if (!mShowPlayers && shape->getType() == PlayerObjectType)
							continue;

						if (!mShowVehicles && shape->getType() == VehicleObjectType) 
							continue;

                        if (!mShowBots && shape->getType() == AIObjectType)
                            continue;
					}

					Point3F newCoord;
   					// Get coords of player object
					newCoord = shape->getPosition();

					// Find distance from point A (player object) to point B (client's player)
					VectorF shapeDir = newCoord - mMyCoords;

					// Test to see if player object in range (deal with squared objects in cheap way to use non-negative value)
					F32 shapeDist = shapeDir.lenSquared();
					if (shapeDist == 0 || shapeDist > (mRadarRadiusRange * mRadarRadiusRange))
						continue;

					// Convert map coordinates to screen coordinates
					newCoord.x -= mMyCoords.x;
					newCoord.y -= mMyCoords.y;
					newCoord.y = -newCoord.y;
					
					float coord_z = newCoord.z - mMyCoords.z; 

					newCoord.z = 0;

					// Adjust object's vector to represent rotation of camera
					float objectAngle = Vector3dToDegree(newCoord);
					float length = newCoord.len()*HW/mRadarRadiusRange;
					DegreeToVector2d(((360-objectAngle)+(cameraAngle) ), length, newCoord);
					
					newCoord.x = -newCoord.x;

					// Add tour calculation to the centre of the GuiControl
					newCoord.x += (center.x);
					newCoord.y += (center.y);
						
					// Draw radar blips based on height
					if(coord_z < F32(0 - mLevelRange)){
						if (LowBlip) 
						{
							GFX->getDrawUtil()->drawBitmap(LowBlip, Point2I(newCoord.x,newCoord.y));
						}
					}
					else if(coord_z > mLevelRange){
						if (HighBlip) 
						{
							GFX->getDrawUtil()->drawBitmap(HighBlip, Point2I(newCoord.x,newCoord.y));
						}
					}
					else{
						if (LevelBlip) 
						{
							GFX->getDrawUtil()->drawBitmap(LevelBlip, Point2I(newCoord.x,newCoord.y));
						}
					}
					}
				}
			}
		}

   if (mProfile->mBorder || !mRadarTextureObject)
   {
		if (mShowFrame)
		{
			RectI rect(offset.x, offset.y, getExtent().y, getExtent().x);
			GFX->getDrawUtil()->drawRect(rect, mProfile->mBorderColor);
		}
   }
	
   if (mCompassTextureObject && mShowCompass)
   {

		GFX->getDrawUtil()->clearBitmapModulation();

		GFXTextureObject* texture = mCompassTextureObject;

        setupStateBlocks();
        GFX->setStateBlock(mBeforeStateBlock);

		GFX->setTexture( 0, texture );
		GFX->disableShaders();

		F32 width = getExtent().y * 0.5;

		MatrixF rotMatrix( EulerF( 0.0, 0.0, mDegToRad(cameraAngle)));

		Point3F offset( offset.x + getExtent().y / 2,
			offset.y + getExtent().x / 2, 0.0);

		Point3F points[4];
		points[0] = Point3F(-width, -width, 0.0f);
		points[1] = Point3F(-width, width, 0.0f);
		points[2] = Point3F( width, width, 0.0f);
		points[3] = Point3F( width, -width, 0.0f);

		for(int i = 0; i < 4; i++)
		{
			rotMatrix.mulP( points[i] );
			points[i] += offset;
		}

		PrimBuild::color3f(1.0f,1.0f,1.0f);

		PrimBuild::begin(GFXTriangleFan, 4);
		PrimBuild::texCoord2f(0, 0);
		PrimBuild::vertex3fv(points[0]);
		PrimBuild::texCoord2f(0, 1);
		PrimBuild::vertex3fv(points[1]);
		PrimBuild::texCoord2f(1, 1);
		PrimBuild::vertex3fv(points[2]);
		PrimBuild::texCoord2f(1, 0);
		PrimBuild::vertex3fv(points[3]);
		PrimBuild::end();

		GFX->setStateBlock(mBlendDisabledStateBlock);

	}

   renderChildControls(offset, updateRect);
}

void GuiRadarCtrl::setupStateBlocks()
{
   if (mBeforeStateBlock.isNull())
   {
       GFXStateBlockDesc desc;
       
       desc.setCullMode(GFXCullNone);
       //desc.setZEnable(false);

       desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);

       desc.samplersDefined = true;
       desc.samplers[0].textureColorOp = GFXTOPModulate;
       desc.samplers[1].textureColorOp = GFXTOPDisable;
	   desc.samplers[0].addressModeU = GFXAddressWrap;
       desc.samplers[0].addressModeV = GFXAddressWrap;

       mBeforeStateBlock = GFX->createStateBlock( desc );
   }

   if (mBlendDisabledStateBlock.isNull())
   {
      GFXStateBlockDesc desc;
      desc.setBlend(false, GFXBlendOne, GFXBlendZero);
      mBlendDisabledStateBlock = GFX->createStateBlock( desc );
   }

}

//-----------------------------------------------------------------------------
// Torque Game Engine Advanced
// Copyright (C) GarageGames.com, Inc.
// Convertion to TGEA 1.8.1 with karakurty
//-----------------------------------------------------------------------------

#ifndef _GUIRADARCTRL_H_
#define _GUIRADARCTRL_H_

#ifndef _GUIBITMAPCTRL_H_
#include "gui/controls/guiBitmapCtrl.h"
#endif

/// Renders a bitmap.
class GuiRadarCtrl : public GuiBitmapCtrl //GuiControl
{
private:
	typedef /*GuiControl*/ GuiBitmapCtrl Parent;
	Point3F mMyCoords;

protected:
	// Radar
    StringTableEntry mRadarBitmapName;
	StringTableEntry mBlipUpName;
	StringTableEntry mBlipLevelName;
	StringTableEntry mBlipBelowName;

    GFXTexHandle mRadarTextureObject;
    GFXTexHandle mRadarDot;
    GFXTexHandle mRadarUp;
    GFXTexHandle mRadarDown;

	bool mShowRadar;

	bool mShowVehicles;
	bool mShowPlayers;
	bool mShowShapeBase;
    bool mShowBots;
	bool mShowFrame;

	F32 mLevelRange;
	F32 mRadarRadiusRange;

	bool mHideAll;

	//Compass
	StringTableEntry mCompassBitmapName;
	GFXTexHandle mCompassTextureObject;

	bool mShowCompass;

	// <MH>
	// Map
	StringTableEntry mMapBitmapName;
	GFXTexHandle mMapTextureObject;

	bool mShowMap;

	F32 mCompassRotation;
	// </MH>

    Point2I startPoint;
    //bool mRadarWrap;

	GFXStateBlockRef mBlendDisabledStateBlock;
	GFXStateBlockRef mBeforeStateBlock;

public:
    //creation methods
    DECLARE_CONOBJECT(GuiRadarCtrl);
    GuiRadarCtrl();
    static void initPersistFields();

    //Parental methods
    bool onWake();
    void onSleep();
    void inspectPostApply();

    void setRadarBitmap(const char *name, bool resize = false);
    void setRadarBitmap(GFXTexHandle handle, bool resize = false);

	void setRadarLevelBlipBitmap(const char *name);
	void setRadarUpBlipBitmap(const char *name);
	void setRadarBelowBlipBitmap(const char *name);

	void setCompassBitmap(const char *name, bool resize = false);
	void setCompassBitmap(GFXTexHandle handle, bool resize = false);

	void setMapBitmap(const char *name);

	void setRadius(const F32 newRange);
	void setLevelRange(const F32 newLevelRange);

    S32 getWidth() const       { return ( (mRadarTextureObject == NULL) ? 0 : mRadarTextureObject->getWidth() ) ; }
    S32 getHeight() const      { return( (mRadarTextureObject == NULL) ? 0 : mRadarTextureObject->getHeight() ); }

	void setCompassRotation(const F32 rotation);

    void onRender(Point2I offset, const RectI &updateRect);

	void setupStateBlocks();
};

#endif

//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------
// Class: GuiRadarTSCtrl for TGEA
// Tested with TGEA 1.0.3
// A 3d Spherical Radar system, ideal for space and flight games
// If you've played Elite, you know the score :)
// Uses some ideas from the GuiRadarCtrl by Matt "CaptFallout" Webster
// Guy Allard 2008
//-----------------------------------------------------------------------------
// Upgraded and cleaned by James Laker
//-----------------------------------------------------------------------------
#include "platform/platform.h"

#include "gui/core/guiControl.h"
#include "gfx/gfxDrawUtil.h"
#include "T3D/player.h"

#include "console/console.h"

#include "gfx/gfxDevice.h"
#include "app/game.h"

#include "T3D/ShapeBase.h"
#include "gui/controls/guiRadarTSCtrl.h"
#include "console/consoleTypes.h"
#include "t3d/gameConnection.h"
#include "t3d/shapeBase.h"
#include "t3d/sphere.h"
#include "gfx/primBuilder.h"

IMPLEMENT_CONOBJECT(GuiRadarTSCtrl);

// vertices for the quad used for rendering the elliptic plane
static const Point3F planeVerts[4]=
{
   Point3F(-1, 1, 0),
   Point3F(1, 1, 0),
   Point3F(-1, -1, 0),
   Point3F(1, -1, 0)
};

// and these are for the blip billboards
static const Point3F quadVerts[4]=
{
   Point3F(-1, 0, 1),
   Point3F(1, 0, 1),
   Point3F(-1, 0, -1),
   Point3F(1, 0, -1)
};

// texture coords for the quads (when drawn as a trianglestrip)
static const Point2F quadTexCoords[4] =
{
   Point2F(0,0),
   Point2F(1,0),
   Point2F(0,1),
   Point2F(1,1)
};

// sphere
static Sphere sphere(Sphere::Icosahedron);

//--------------------------------------------------------------------------
GuiRadarTSCtrl::GuiRadarTSCtrl()
{

	 mSphereDetail = 2;

   // textures
   mEllipticBitmap = StringTable->insert("");
   mEllipticTextureHandle = NULL;
   mBlipBitmap = StringTable->insert("");
   mBlipTextureHandle = NULL;
	mTargetBlipBitmap = StringTable->insert("");
	mTargetBlipTextureHandle = NULL;

	strcpy(mTargetShapeName,"");

   // colors
   mEllipticColor.set(0.0, 0.75, 0.0, 0.75);
   mSphereColor.set(0.0f, 0.5f, 0.0f, 0.25f);
   mBlipColor.set(1.0f, 1.0f, 1.0f, 1.0f);
   mStemColor.set(1.0f, 1.0f, 1.0f, 1.0f);

   // range
   mRange = 250.0f;

   // blip size
   mBlipSize = 1.0f;
}

//---------------------------------------------------------------------------
void GuiRadarTSCtrl::initPersistFields()
{
	Parent::initPersistFields();

	addGroup("Radar");
	addField("PlaneBitmap",		TypeFilename,	   Offset(mEllipticBitmap,    GuiRadarTSCtrl));
   addField("PlaneColor",     TypeColorF,       Offset(mEllipticColor,     GuiRadarTSCtrl));
   addField("BlipBitmap",     TypeFilename,     Offset(mBlipBitmap,        GuiRadarTSCtrl));
   addField("BlipColor",	   TypeColorF,       Offset(mBlipColor,         GuiRadarTSCtrl));
   addField("BlipSize",       TypeF32,          Offset(mBlipSize,          GuiRadarTSCtrl));
   addField("StemColor",      TypeColorF,       Offset(mStemColor,         GuiRadarTSCtrl));
   addField("SphereColor",    TypeColorF,       Offset(mSphereColor,       GuiRadarTSCtrl));
	 addField("SphereDetail",    TypeS32,       Offset(mSphereDetail,       GuiRadarTSCtrl));
   addField("Range",          TypeF32,          Offset(mRange,             GuiRadarTSCtrl));
	endGroup("Radar");
}

void GuiRadarTSCtrl::setTarget(const char *TargetShapeBaseName)
{
	if (*TargetShapeBaseName)
		strcpy(mTargetShapeName,TargetShapeBaseName);	
}

//---------------------------------------------------------------------------
void GuiRadarTSCtrl::setEllipticBitmap(const char *name)
{
   mEllipticBitmap = StringTable->insert(name);

   if (*mEllipticBitmap) 
	  mEllipticTextureHandle = GFXTexHandle(mEllipticBitmap, &GFXDefaultStaticDiffuseProfile, "Adescription");
      //mEllipticTextureHandle = GFXTexHandle(mEllipticBitmap, &GFXDefaultStaticDiffuseProfile);
   else 
      // Reset handles if UI object is hidden
	   mEllipticTextureHandle = NULL;
   
   setUpdate();
}

//---------------------------------------------------------------------------
void GuiRadarTSCtrl::setBlipBitmap(const char *name)
{
   mBlipBitmap = StringTable->insert(name);

   if (*mBlipBitmap) 
	  mBlipTextureHandle = GFXTexHandle(mBlipBitmap, &GFXDefaultStaticDiffuseProfile, "Adescription");
      //mBlipTextureHandle = GFXTexHandle(mBlipBitmap, &GFXDefaultStaticDiffuseProfile);
   else 
      // Reset handles if UI object is hidden
	   mBlipTextureHandle = NULL;
   
   setUpdate();
}

//---------------------------------------------------------------------------
bool GuiRadarTSCtrl::onWake()
{
	if (! Parent::onWake())
		return false;
	setActive(true);

	setEllipticBitmap(mEllipticBitmap);
   setBlipBitmap(mBlipBitmap);

   return true;
}

//--------------------------------------------------------------------------
void GuiRadarTSCtrl::onSleep()
{
	mEllipticTextureHandle = NULL;
   mBlipTextureHandle = NULL;
	Parent::onSleep();
}

//---------------------------------------------------------------------------
// set up the camera position for rendering the 3D scene within this control
bool GuiRadarTSCtrl::processCameraQuery(CameraQuery *camq)
{
   // pretty hacky hardcoded values
   // gives a reasonable viewing angle
   camq->nearPlane = 0.1f; // near clip plane
   camq->farPlane = 20.0f; // far clip plane
   camq->fov = (F32)M_PI/6;     // field of view
   MatrixF cam;
   cam.set(EulerF((F32)M_PI/8, 0, 0)); // rotation
   cam.setColumn(3, Point3F(0, -4, 1.65f)); // position
   camq->cameraMatrix = cam;
   return (true);
}

//---------------------------------------------------------------------------
// render the world that this control sees
void GuiRadarTSCtrl::renderWorld(const RectI &updateRect)
{
   // Must have a connection
   GameConnection* conn = GameConnection::getConnectionToServer();
   if (!conn) return;
   
   // Must have controlled object
   GameBase * control = dynamic_cast<GameBase*>(conn->getControlObject());
   if (!control) return;

   // get the camera transform for the connection
   MatrixF camMat;
   conn->getControlCameraTransform(0,&camMat);
   // get the position for use later
   Point3F camPos = camMat.getPosition();

   // invert the camera transform - 
   // this will then allow us to transform other objects into our own object space
   camMat.inverse();

   // set up the graphics

   // HNG
   /*
   GFX->setAlphaBlendEnable(true);
   GFX->setSrcBlend(GFXBlendSrcAlpha);
   GFX->setDestBlend(GFXBlendInvSrcAlpha);
   GFX->setZEnable( false );
   GFX->setCullMode( GFXCullNone );
   GFX->setTextureStageColorOp(0, GFXTOPModulate);
	GFX->setTextureStageColorOp(1, GFXTOPDisable);
   GFX->disableShaders();*/



   GFXStateBlockDesc desc;
   desc.zEnable = false;
   desc.ffLighting = false;  
   desc.setCullMode( GFXCullNone );  
   desc.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);  
   desc.samplers[0].textureColorOp = GFXTOPModulate;  
   desc.samplers[1].textureColorOp = GFXTOPDisable;
   GFXStateBlockRef myState = GFX->createStateBlock(desc);  
   GFX->setStateBlock(myState);
   // HNG

   // first draw the elliptic plane if we need to
   if(mEllipticTextureHandle)
   {
      GFXTextureObject *texture = mEllipticTextureHandle;
      GFX->setTexture(0, texture);

	   PrimBuild::color(mEllipticColor);
      PrimBuild::begin(GFXTriangleStrip, 4);
      for(int i=0; i<4; i++)
      {
         PrimBuild::texCoord2f(quadTexCoords[i].x, quadTexCoords[i].y);
		   PrimBuild::vertex3fv(planeVerts[i]);
      }
      PrimBuild::end();
   }
   
	 if (mSphereDetail > 4)
			mSphereDetail = 4;

const Sphere::TriangleMesh *sphereMesh = sphere.getMesh(mSphereDetail); // sphere.getMesh(2) gives a slighty 'chunky' sphere - go higher if you can handle the framerate hit  
    S32 numPoly = sphereMesh->numPoly;  
    S32 totalPoly = 0;  
  
    GFXVertexBufferHandle<GFXVertexPC> verts(GFX, numPoly*3, GFXBufferTypeVolatile);  
    verts.lock();  
    S32 vertexIndex = 0;  
    for (S32 i=0; i<numPoly; i++)  
    {  
        totalPoly++;  
  
        verts[vertexIndex].point = sphereMesh->poly[i].pnt[0];  
        verts[vertexIndex].color = mSphereColor;  
        vertexIndex++;  
  
        verts[vertexIndex].point = sphereMesh->poly[i].pnt[1];  
        verts[vertexIndex].color = mSphereColor;  
        vertexIndex++;  
  
        verts[vertexIndex].point = sphereMesh->poly[i].pnt[2];  
        verts[vertexIndex].color = mSphereColor;  
        vertexIndex++;  
    }  
    verts.unlock();  
  
    GFXStateBlockDesc desc2;  
    desc2.setCullMode(GFXCullNone);  
    desc2.zEnable = false;  
    desc2.setBlend(true, GFXBlendSrcAlpha, GFXBlendInvSrcAlpha);  
  
    GFX->setStateBlockByDesc( desc2 );  
    GFX->setupGenericShaders( GFXDevice::GSColor );  
  
    GFX->setVertexBuffer( verts );  
    GFX->drawPrimitive( GFXTriangleList, 0, totalPoly );  
  
    GFX->setStateBlockByDesc( desc );  
    GFX->setupGenericShaders(); 
   
   // Now do the radar signatures
   // firstly, we will be drawing billboards, so get the current world transform matrix
   MatrixF worldMat = GFX->getWorldMatrix();
   // extract the up and right vectors
   Point3F up;
   Point3F right;
   worldMat.getRow(0,&right);
   worldMat.getRow(2,&up);
   right.normalize();
   up.normalize();
   // then build the coordinates that we'll use for the billboards
   // oops, another hard coded value, ah well...
   right *= mBlipSize * 0.05f;
   up    *= mBlipSize * 0.05f; 

   // set up the texture that we'll use for the blips
   // is this the correct way to do it???
   GFXTextureObject *texture = mBlipTextureHandle;
	GFXTextureObject *targetTexture = mTargetBlipTextureHandle;

   // Go through all ghosted objects on connection (client-side)
   for (SimSetIterator itr(conn); *itr; ++itr) 
   {
	   // Make sure that the object is a shapebase object
	   if ((*itr)->getType() & ShapeBaseObjectType) 
      {
		   ShapeBase* shape = static_cast<ShapeBase*>(*itr);
		   // Make sure that the object isn't the client
		   if (shape != control) 
         {
			   // Make sure the shapebase object is a player (or Vehicle)
			   if (shape->getType() & ( PlayerObjectType | VehicleObjectType ) ) 
            {
               // get position of object
				   Point3F objPos = shape->getPosition();

               // get vector between object and observer
               Point3F objVec = objPos - camPos;

               // don't draw if outside of current radar range
               if(objVec.lenSquared() > (mRange * mRange))
                  continue;
               
               // transform it into the coordinate space of the viewer
               camMat.mulP(objPos);

               // scale it according to the current radar range
               objPos /= mRange;

               // compress the z transform a bit, just for looks
               //objPos.z *= 0.5f;

					if (!strcmp(mTargetShapeName,""))
						GFX->setTexture(0, targetTexture);
					else
						GFX->setTexture(0, texture);

               // draw the blip
               // unfortunately, DX doesn't appear to allow specification of point size or line width like opengl
               // SO, lets build a quad using the view aligned coordinates we generated earlier....
               desc.samplers[0].textureColorOp = GFXTOPModulate;
			//GFX->setTextureStageColorOp(0, GFXTOPModulate);
               PrimBuild::color(mBlipColor);
               PrimBuild::begin(GFXTriangleStrip, 4);
                  PrimBuild::texCoord2f(quadTexCoords[0].x, quadTexCoords[0].y);
                  PrimBuild::vertex3fv(objPos - right + up);
                  PrimBuild::texCoord2f(quadTexCoords[1].x, quadTexCoords[1].y);
                  PrimBuild::vertex3fv(objPos + right + up);
                  PrimBuild::texCoord2f(quadTexCoords[2].x, quadTexCoords[2].y);
                  PrimBuild::vertex3fv(objPos - right - up);
                  PrimBuild::texCoord2f(quadTexCoords[3].x, quadTexCoords[3].y);
                  PrimBuild::vertex3fv(objPos + right - up);
               PrimBuild::end();
               
               // draw a line from the blip to the elliptic - will have to use quads if you want a line thicker than 1px
               // end point of line
               Point3F endPos = objPos;
               endPos.z = 0;

               // draw the line
			   desc.samplers[1].textureColorOp = GFXTOPDisable;
               //GFX->setTextureStageColorOp(0, GFXTOPDisable);
               PrimBuild::color(mStemColor);
               PrimBuild::begin(GFXLineList, 2);
                  PrimBuild::vertex3fv(objPos);
                  PrimBuild::vertex3fv(endPos);
               PrimBuild::end();
			   }
		   }
	   }
   }
   
   // all done
   GFX->setClipRect(updateRect);
       
}

//------------------------------------------------------------------------
// script interface
ConsoleMethod( GuiRadarTSCtrl, setEllipticBitmap, void, 3, 3, "(string filename)"
              "Set the bitmap for the horizontal plane of the control.")
{
   object->setEllipticBitmap(argv[2]);
}

ConsoleMethod( GuiRadarTSCtrl, SetRange, void, 3, 3, "(float)"
              "Sets the Range of the the control. Default is 250")
{
   object->setRange(dAtof(argv[2]));
}

ConsoleMethod( GuiRadarTSCtrl, getRange, F32, 2, 2, "()"
              "gets the current range of the control")
{
   return object->getRange();
}

ConsoleMethod( GuiRadarTSCtrl, setEllipticColor, void, 3, 3, "(Color)"
              "set the color of the horizontal plane")
{
   ColorF color;
   dSscanf(argv[2], "%g %g %g %g", &color.red, &color.green, &color.blue, &color.alpha);
   object->setEllipticColor(color);
}

ConsoleMethod( GuiRadarTSCtrl, setSphereColor, void, 3, 3, "(Color)"
              "set the color of the sphere")
{
   ColorF color;
   dSscanf(argv[2], "%g %g %g %g", &color.red, &color.green, &color.blue, &color.alpha);
   object->setSphereColor(color);
}

ConsoleMethod( GuiRadarTSCtrl, setBlipColor, void, 3, 3, "(Color)"
              "set the color of the radar blips")
{
   ColorF color;
   dSscanf(argv[2], "%g %g %g %g", &color.red, &color.green, &color.blue, &color.alpha);
   object->setBlipColor(color);
}

ConsoleMethod( GuiRadarTSCtrl, setStemColor, void, 3, 3, "(Color)"
              "set the color of the blip lines")
{
   ColorF color;
   dSscanf(argv[2], "%g %g %g %g", &color.red, &color.green, &color.blue, &color.alpha);
   object->setStemColor(color);
}

ConsoleMethod( GuiRadarTSCtrl, setTarget, void, 2, 3, "(str Target ShapebaseName)"
               "Set the target ShapeBaseName, if no Target is sent it is cleared.")
{
	if (argv[2])
		object->setTarget(argv[2]);
	else
		object->setTarget("");

}

//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------

#ifndef _GUIRADARTSCTRL_H_
#define _GUIRADARTSCTRL_H_

#ifndef _GUITSCONTROL_H_
#include "gui/3d/guiTSControl.h"
#endif
#ifndef _GFXTEXTUREHANDLE_H_
#include "gfx/gfxTextureHandle.h"
#endif

//----------------------------------------------------------------------------
class GuiRadarTSCtrl : public GuiTSCtrl
{
private:
   typedef GuiTSCtrl Parent;

   StringTableEntry  mEllipticBitmap;           // path to the bitmap for the horizontal plane
   GFXTexHandle      mEllipticTextureHandle;    // texture handle for the horizontal plane

   StringTableEntry  mBlipBitmap;               // path to the bitmap we'll use for the blips
   GFXTexHandle      mBlipTextureHandle;        // texture handle for the blip texture

   StringTableEntry  mTargetBlipBitmap;               // path to the bitmap we'll use for the blips
   GFXTexHandle      mTargetBlipTextureHandle;        // texture handle for the blip texture

	 S32			mSphereDetail;

   ColorF   mEllipticColor;   // color to use when drawing the elliptic plane
   ColorF   mSphereColor;     // color of the sphere
   ColorF   mBlipColor;       // color for the radar 'blips'
   ColorF   mStemColor;       // color for the stems of the blips
   F32      mRange;           // range of the radar
   F32      mBlipSize;        // base size for the blips

	char		mTargetShapeName[32]; //This keeps the name of the locked target
  
public:
   GuiRadarTSCtrl();

   bool processCameraQuery(CameraQuery *query);
   void renderWorld(const RectI &updateRect);
   
   static void initPersistFields();
   bool onWake();
	void onSleep();

   // gets and sets
   void setEllipticBitmap(const char *name);
   void setBlipBitmap(const char *name);
   void setRange(F32 range) { mRange = range; }
   F32 getRange() { return mRange; }
   void setEllipticColor(ColorF color) { mEllipticColor = color; }
   void setSphereColor(ColorF color) { mSphereColor = color; }
   void setBlipColor(ColorF color) { mBlipColor = color; }
   void setStemColor(ColorF color) { mStemColor = color; }

	void setTarget(const char *TargetShapeBaseName);

   DECLARE_CONOBJECT(GuiRadarTSCtrl);
};

#endif