guiminimap.cc

五行MMORPG引擎系统V1.0

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

#include "gui/game/guiMiniMap.h"
#include "dgl/gBitmap.h"
#include "terrain/terrData.h"
#include "sim/sceneObject.h"
#include "dgl/dgl.h"
#include "console/consoleTypes.h"
#include "gui/core/guiCanvas.h"
#include "gui/core/guiTSControl.h"
#include "game/game.h"
#include "game/objectTypes.h"
#include "game/shapeBase.h"
#include "game/gameConnection.h"
#include "core/bitMatrix.h"
#include "gui/controls/guiTextCtrl.h"

IMPLEMENT_CONOBJECT(GuiMiniMapCtrl);

// unnamed namespace for static data
namespace {
   static const Point3F BoxNormals[] =
   {
      Point3F( 1, 0, 0),
      Point3F(-1, 0, 0),
      Point3F( 0, 1, 0),
      Point3F( 0,-1, 0),
      Point3F( 0, 0, 1),
      Point3F( 0, 0,-1)
   };

   static U32 BoxVerts[][4] = {
      {7,6,4,5},     // +x
      {0,2,3,1},     // -x
      {7,3,2,6},     // +y
      {0,1,5,4},     // -y
      {7,5,1,3},     // +z
      {0,4,6,2}      // -z
   };

   static Point3F BoxPnts[] = {
      Point3F(0,0,0),
      Point3F(0,0,1),
      Point3F(0,1,0),
      Point3F(0,1,1),
      Point3F(1,0,0),
      Point3F(1,0,1),
      Point3F(1,1,0),
      Point3F(1,1,1)
   };

   F32 round_local(F32 val)
   {
      if(val >= 0.f)
      {
         F32 floor = mFloor(val);
         if((val - floor) >= 0.5f)
            return(floor + 1.f);
         return(floor);
      }
      else
      {
         F32 ceil = mCeil(val);
         if((val - ceil) <= -0.5f)
            return(ceil - 1.f);
         return(ceil);
      }
   }

   S32 clamp(S32 val, S32 resolution)
   {
      return(S32(round_local(F32(val) / F32(resolution))) * resolution);
   }
}


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

GuiMiniMapCtrl::GuiMiniMapCtrl()
{
   //
   //mTerrainBlock = 0;


   // field data
   mSquareBitmap = true;
   mRenderCamera = true;

   mHandleFrameColor.set(255,255,255);
   mHandleFillColor.set(0,0,0);
   mDefaultObjectColor.set(0,255,0,100);
   mWaterObjectColor.set(0,0,255,100);
   mMissionBoundsColor.set(255,0,0);
   mCameraColor.set(255,0,0);
	//dStrcpy(mMiniMapName,"MiniMapTitle");

}





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

//TerrainBlock * GuiMiniMapCtrl::getTerrainObj()
//{
//   //SimSet * scopeAlwaysSet = Sim::getGhostAlwaysSet();
//   //for(SimSet::iterator itr = scopeAlwaysSet->begin(); itr != scopeAlwaysSet->end(); itr++)
//	GameConnection* con = GameConnection::getConnectionToServer();
//	if(!con)
//		return 0;
//
//   for(SimSet::iterator itr = con->begin(); itr != con->end(); itr++)
//   {
//      TerrainBlock * terrain = dynamic_cast<TerrainBlock*>(*itr);
//      if(terrain)
//         return(terrain);
//   }
//   return(0);
//}

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

GBitmap * GuiMiniMapCtrl::createTerrainBitmap()
{
	if(g_pTerrainBlock == 0)
		return 0;

   GBitmap * bitmap = new GBitmap(TerrainBlock::BlockSize, TerrainBlock::BlockSize, false, GBitmap::RGB);
   if(!bitmap)
      return(0);

   U8 * pBits = bitmap->getAddress(0,0);

   // get the min/max
   GridSquare * gSquare = g_pTerrainBlock->findSquare(TerrainBlock::BlockShift, Point2I(0,0));

   F32 min = fixedToFloat(gSquare->minHeight);
   F32 max = fixedToFloat(gSquare->maxHeight);
   F32 diff = max - min;

   for(U32 y = 0; y < TerrainBlock::BlockSize; y++)
      for(U32 x = 0; x < TerrainBlock::BlockSize; x++)
      {
         F32 height = fixedToFloat(g_pTerrainBlock->getHeight(x, y));

         U8 col = U8((height - min) / diff * 255.f);
         *pBits++ = col;
         *pBits++ = col;
         *pBits++ = col;
      }

   return(bitmap);
}

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

bool GuiMiniMapCtrl::onAdd()
{
   if(!Parent::onAdd())
      return(false);
	//if(!mMiniMapName[0])
	//	mMiniMapName = DEFAULT_MINIMAPTITLE;
	return(true);
}

void GuiMiniMapCtrl::inspectPostApply()
{
	Parent::inspectPostApply();
	//if(!mMiniMapName[0])
	//	mMiniMapName = DEFAULT_MINIMAPTITLE;
	//mMiniMapTitle = static_cast<GuiTextCtrl*>(Sim::findObject(mMiniMapName));
}


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

void GuiMiniMapCtrl::updateTerrainBitmap()
{
   const GBitmap * bitmap = createTerrainBitmap();
   if(bitmap)
      setBitmap(TextureHandle("maTerrain", bitmap, true));
}

bool GuiMiniMapCtrl::onWake()
{
   if(!Parent::onWake())
      return(false);


   //mTerrainBlock = getTerrainObj();
   if(!bool(g_pTerrainBlock))
   {
      Con::errorf(ConsoleLogEntry::General, "GuiMiniMapCtrl::onWake: no TerrainBlock object.");
      return true;

      //return(false);
   }
	//mMiniMapTitle = static_cast<GuiTextCtrl*>(Sim::findObject(mMiniMapName));
   updateTerrainBitmap();


   setActive(true);

   return(true);
}

void GuiMiniMapCtrl::onSleep()
{
   mTextureHandle = NULL;
   //mTerrainBlock = 0;

   Parent::onSleep();
}

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


void GuiMiniMapCtrl::parentResized(const Point2I & oldParentExtent, const Point2I & newParentExtent)
{
   static Point2I offset = (oldParentExtent - getPosition()) - getExtent();
   resize(getPosition(), newParentExtent - getPosition() - offset);
}


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

Point2F GuiMiniMapCtrl::worldToScreen(const Point2F & pos)
{
   return(Point2F(mCenterPos.x + (pos.x * mScale.x), mCenterPos.y + (pos.y * mScale.y)));
}

Point2F GuiMiniMapCtrl::screenToWorld(const Point2F & pos)
{
   return(Point2F((pos.x - mCenterPos.x) / mScale.x, (pos.y - mCenterPos.y) / mScale.y));
}

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

void GuiMiniMapCtrl::setupScreenTransform(const Point2I & offset)
{
	if(g_pTerrainBlock == 0)
		return;

   const MatrixF & terrMat = g_pTerrainBlock->getTransform();
   Point3F terrPos;
   terrMat.getColumn(3, &terrPos);
   terrPos.z = 0;

   F32 terrDim = F32(g_pTerrainBlock->getSquareSize() * TerrainBlock::BlockSize);

   const Point2I& extenti = getExtent( );
   Point2F extent( static_cast<F32>( extenti.x ), static_cast<F32>( extenti.y ) );

   if(mSquareBitmap)
      extent.x > extent.y ? extent.x = extent.y : extent.y = extent.x;

   //
   mScale.set(extent.x / terrDim, extent.y / terrDim, 0);

   Point3F terrOffset = -terrPos;
   terrOffset.convolve(mScale);

   //
   mCenterPos.set(terrOffset.x + F32(offset.x), terrOffset.y + F32(offset.y));
}

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

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

void GuiMiniMapCtrl::onPreRender()
{
	//if(!mMiniMapTitle.isNull())
	//{
	//	GameConnection * connection = GameConnection::getLocalClientConnection();

	//	ShapeBase * obj = 0;
	//	if(connection)
	//		obj = connection->getControlObject();