D-Pad / Joystick GUI Ctrl for iTGB

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

#include "console/console.h"
#include "console/consoleTypes.h"
#include "dgl/dgl.h"
#include "mMathFn.h"
#include "T2D/t2dVector.h"
#include "t2dSceneObject.h"

#include "gui/controls/GuiControlDisc.h"

IMPLEMENT_CONOBJECT(GuiControlDisc);

GuiControlDisc::GuiControlDisc(void)
{
	mBitmapName = StringTable->insert("");
	startPoint.set(0, 0);
	mWrap = false;
#ifdef _LUMA
	//ability to specify source rect for image UVs
	mUseSourceRect = false;
	mSourceRect.set(0, 0, 0, 0);
#endif //_LUMA
	
}

bool GuiControlDisc::setBitmapName( void *obj, const char *data )
{
	// Prior to this, you couldn't do bitmap.bitmap = "foo.jpg" and have it work.
	// With protected console types you can now call the setBitmap function and
	// make it load the image.
	static_cast<GuiControlDisc *>( obj )->setBitmap( data );
	
	// Return false because the setBitmap method will assign 'mBitmapName' to the
	// argument we are specifying in the call.
	return false;
}

void GuiControlDisc::initPersistFields()
{
	Parent::initPersistFields();
	addGroup("GuiControlDisc");		
	addProtectedField( "bitmap", TypeFilename, Offset( mBitmapName, GuiControlDisc ), &setBitmapName, &defaultProtectedGetFn, "" );
	endGroup("GuiControlDisc");		
	
#ifdef	_LUMA
	addGroup("Misc");
	//ability to specify source rect for image UVs
	addField( "useSourceRect", TypeBool, Offset( mUseSourceRect, GuiControlDisc ));
	addField( "sourceRect", TypeRectI, Offset( mSourceRect, GuiControlDisc ));
	endGroup("Misc");	
#endif	//_LUMA	
}

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

ConsoleMethod( GuiControlDisc, setBitmap, void, 3, 3, "( pathName ) Use the setBitmap method to change the bitmap this control uses.n"
			  "@param pathName A path to a new texture for this control. Limited to 256x256.n"
			  "@return No return value")
{
	object->setBitmap(argv[2]);
}


bool GuiControlDisc::onWake()
{
	if (! Parent::onWake())
		return false;
	setActive(true);
	setBitmap(mBitmapName);
	return true;
}

void GuiControlDisc::onSleep()
{
	mTextureHandle = NULL;
	Parent::onSleep();
}

//-------------------------------------
void GuiControlDisc::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 (!mWrap && (mBounds.extent.x == 0) && (mBounds.extent.y == 0) && mTextureHandle)
	{
		TextureObject *texture = (TextureObject *) mTextureHandle;
		mBounds.extent.x = texture->bitmapWidth;
		mBounds.extent.y = texture->bitmapHeight;
	}
}

void GuiControlDisc::setBitmap(const char *name, bool resize)
{
	mBitmapName = StringTable->insert(name);
	if (*mBitmapName) {
		mTextureHandle = TextureHandle(mBitmapName, BitmapTexture, true);
		
		// Resize the control to fit the bitmap
		if (resize) {
			TextureObject* texture = (TextureObject *) mTextureHandle;
			mBounds.extent.x = texture->bitmapWidth;
			mBounds.extent.y = texture->bitmapHeight;
			GuiControl *parent = getParent();
			if( !parent ) {
				Con::errorf( "GuiControlDisc::setBitmap( %s ), trying to resize but object has no parent.", name ) ;
			} else {
				Point2I extent = parent->getExtent();
				parentResized(extent,extent);
			}
		}
	}
	else
		mTextureHandle = NULL;
	setUpdate();
}


void GuiControlDisc::setBitmap(const TextureHandle &handle, bool resize)
{
	mTextureHandle = handle;
	
	// Resize the control to fit the bitmap
	if (resize) {
		TextureObject* texture = (TextureObject *) mTextureHandle;
		mBounds.extent.x = texture->bitmapWidth;
		mBounds.extent.y = texture->bitmapHeight;
		Point2I extent = getParent()->getExtent();
		parentResized(extent,extent);
	}
}


void GuiControlDisc::onRender(Point2I offset, const RectI &updateRect)
{
	if (mTextureHandle)
	{
		dglClearBitmapModulation();
		if(mWrap)
		{
			// We manually draw each repeat because non power of two textures will 
			// not tile correctly when rendered with dglDrawBitmapTile(). The non POT
			// bitmap will be padded by the hardware, and we'll see lots of slack
			// in the texture. So... lets do what we must: draw each repeat by itself:
			TextureObject* texture = (TextureObject *) mTextureHandle;
			RectI srcRegion;
			RectI dstRegion;
			float xdone = ((float)mBounds.extent.x/(float)texture->bitmapWidth)+1;
			float ydone = ((float)mBounds.extent.y/(float)texture->bitmapHeight)+1;
			
			int xshift = startPoint.x%texture->bitmapWidth;
			int yshift = startPoint.y%texture->bitmapHeight;
			for(int y = 0; y < ydone; ++y)
				for(int x = 0; x < xdone; ++x)
				{
#ifdef	_LUMA
					//ability to specify source rect for image UVs
					if(mUseSourceRect && mSourceRect.isValidRect() )
					{
			 			srcRegion = mSourceRect;
					}
					else
#endif	//_LUMA
						srcRegion.set(0,0,texture->bitmapWidth,texture->bitmapHeight);
  					dstRegion.set( ((texture->bitmapWidth*x)+offset.x)-xshift,
								  ((texture->bitmapHeight*y)+offset.y)-yshift,
								  texture->bitmapWidth,	
								  texture->bitmapHeight);
					dglDrawBitmapStretchSR(texture,dstRegion, srcRegion, false);
				}
		}
		else
		{
			RectI rect(offset, mBounds.extent);
#ifdef	_LUMA
			//ability to specify source rect for image UVs
			if(mUseSourceRect && mSourceRect.isValidRect() )
			{
				RectI srcRegion;
 				srcRegion = mSourceRect;
  				dglDrawBitmapStretchSR(mTextureHandle,rect, srcRegion, false);
			}
			else
#endif	//_LUMA
				dglDrawBitmapStretch(mTextureHandle, rect);
		}
	}
	
	if (mProfile->mBorder || !mTextureHandle)
	{
		RectI rect(offset.x, offset.y, mBounds.extent.x, mBounds.extent.y);
		dglDrawRect(rect, mProfile->mBorderColor);
	}
	
	renderChildControls(offset, updateRect);
}

void GuiControlDisc::setValue(S32 x, S32 y)
{
	if (mTextureHandle)
	{
		TextureObject* texture = (TextureObject *) mTextureHandle;
		x+=texture->bitmapWidth/2;
		y+=texture->bitmapHeight/2;
  	}
  	while (x < 0)
  		x += 256;
  	startPoint.x = x % 256;
	
  	while (y < 0)
  		y += 256;
  	startPoint.y = y % 256;
}

void GuiControlDisc::onMouseDown(const GuiEvent &event)
{
	doPlayerThumbMove(event);

	/*
	//Lock the control
	mouseLock();
	setUpdate();
	 */
}

void GuiControlDisc::onMouseUp(const GuiEvent &event)
{
	char buf[32];
	dSprintf(buf, sizeof(buf), "-1");
	
	Con::executef(2,"joystickManager",buf);	
}

void GuiControlDisc::onMouseDragged(const GuiEvent &event)
{
	doPlayerThumbMove(event);
}

void GuiControlDisc::onMouseLeave(const GuiEvent &event)
{
/*
	mouseUnlock();
	setUpdate();

	char buf[32];
	dSprintf(buf, sizeof(buf), "-1");
	
	Con::executef(2,"joystickManager",buf);	
*/
}

void GuiControlDisc::doPlayerThumbMove(const GuiEvent &event)
{
	Point2I pos = globalToLocalCoord(event.mousePoint);	
	
	F32 xPos = (int)pos.x;
	F32 yPos = (int)pos.y;
	
	t2dVector controlDiscCenter;
	t2dVector controlDiscTouchPos;
	
	controlDiscCenter.mX = mBounds.extent.x / 2.0;
	controlDiscCenter.mY = mBounds.extent.y / 2.0;
	
	controlDiscTouchPos.mX = pos.x;
	controlDiscTouchPos.mY = pos.y;
	
	// find angle
	F32 angleOut = mFmod(mAtan( controlDiscTouchPos.mY - controlDiscCenter.mY , controlDiscTouchPos.mX - controlDiscCenter.mX), (2 * 3.14159));  
	
	// normalize to 0 - 360
	if ( angleOut < 0.0f ) 
		angleOut += (2 * 3.14159);

    F32 sin, cos;
	
    mSinCos( angleOut, sin, cos );
	

   //NOTE: Now you have your data, you can do what you want with it. Let's pretend our player is stored in gGamePlayer. You could now do:
//    F32 speed = 60;
//    F32 finalSin = sin*speed;
//    F32 finalCos = cos*speed;
  // gGamePlayer->setLinearVelocity(finalSin,finalCos);
}

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

#ifndef _GuiControlDisc_H_
#define _GuiControlDisc_H_

#ifndef _GUICONTROL_H_
#include "gui/core/guiControl.h"
#endif
#ifndef _GTEXMANAGER_H_
#include "dgl/gTexManager.h"
#endif

#ifdef PUAP_OPTIMIZE
//-Mat credit for this goes to Luke Lamothe (Luma), allows you to specify a region
//in your GUI image to use, instead of always displaying the whole image, you can clip part
//of it, makes it easy for different GUIS to use one image
#define _LUMA
#endif

/// Renders a bitmap.
class GuiControlDisc : public GuiControl
	{
	private:
		typedef GuiControl Parent;
		
	protected:
		static bool setBitmapName( void *obj, const char *data );
		static const char *getBitmapName( void *obj, const char *data );
		
		StringTableEntry mBitmapName;
		TextureHandle mTextureHandle;
		Point2I startPoint;
		bool mWrap;
		t2dVector mLastTouchPos;
#ifdef _LUMA
		//ability to specify source rect for image UVs
		bool		mUseSourceRect;
		RectI	mSourceRect;
#endif //_LUMA
		
	public:
		//creation methods
		DECLARE_CONOBJECT(GuiControlDisc);
		GuiControlDisc();
		static void initPersistFields();
		
		//Parental methods
		bool onWake();
		void onSleep();
		void inspectPostApply();
		
		void setBitmap(const char *name,bool resize = false);
		void setBitmap(const TextureHandle &handle,bool resize = false);
		void setMouseLeaveBool(bool setMouseLeave);
		void onMouseDown(const GuiEvent &);
		void onMouseUp(const GuiEvent &);
		void onMouseDragged(const GuiEvent &);
		void onMouseLeave(const GuiEvent &event);
                void doPlayerThumbMove(const GuiEvent &event);
		
		S32 getWidth() const       { return(mTextureHandle.getWidth()); }
		S32 getHeight() const      { return(mTextureHandle.getHeight()); }
		
		void onRender(Point2I offset, const RectI &updateRect);
		void setValue(S32 x, S32 y);
	};

#endif