labels.patch - Rigs of Rods - Redmine

     #include "FlexMeshWheel.h"
     #include "FlexObj.h"
     #include "FlexAirfoil.h"
     #include "MovableText.h"
     #include "turboprop.h"
     #include "turbojet.h"
     #include "screwprop.h"
-...
     #include "PositionStorage.h"
     #include "network.h"
     #include "PointColDetector.h"
     #include "PlayerColours.h"
     #ifdef FEAT_TIMING
     #include "BeamStats.h"
     #endif
-...
     #include "ScriptEngine.h"
     #endif
     #ifdef USE_MYGUI
     #include "gui_3dlabels.h"
     #endif // USE_MYGUI
     #include "rornet.h"
     #include "MeshObject.h"
-...
     		delete (*it);
+    	}
     	if(netMT)
     	if(netLabel)
+    	{
     		netMT->setVisible(false);
     		delete netMT;
     		netMT = 0;
     		netLabel->setVisible(false);
     		GUI_3DLabelManager::getSingleton().remove3DLabel(netLabel);
     		netLabel = 0;
+    	}
+    }
-...
     	free_soundsource=0;
     	nodedebugstate=-1;
     	debugVisuals=0;
     	netMT = 0;
     	netLabel = 0;
     	beam_creak=BEAM_CREAK_DEFAULT;
     	dynamicMapMode=0;
     	meshesVisible=true;
-...
     	reset_requested=0;
     	mrtime=0.0;
     	free_flexbody=0;
     	netLabelNode=0;
     	free_rigidifier=0;
     	autopilot=0;
     	free_rotator=0;
-...
     	hfinder=mfinder;
     	mWindow=win;
     	beamsRoot=parent->createChildSceneNode();
     	deletion_sceneNodes.push_back(netLabelNode);
     	parentNode=parent;
     	//			float gears[]={6.0, 3.0, 1.5, 1.0, 0.75};
-...
     							//sparks
     							if (!nodes[i].iswheel && ns>1.0 && !nodes[i].disable_particles)
+    							{
     								// friction < 10 will remove the 'f' nodes from the spark generation nodes
     								if(sparksp) sparksp->allocSparks(nodes[i].AbsPosition, nodes[i].Velocity);
+    							}
     						} else if (gm->fx_type==FX_CLUMPY)
-...
+    	}
     	//Flex body
     	for (i=0; i<free_flexbody; i++) flexbodies[i]->flexit();
     	if (netLabelNode && netMT && netMT->isVisible())
+    	{
     		// this ensures that the nickname is always in a readable size
     		netLabelNode->setPosition(position+Vector3(0, (maxy-miny), 0));
     		Vector3 vdir=(position)-mCamera->getPosition();
     		float vlen=vdir.length();
     		float h = vlen/30.0;
     		if(h<0.6)
     			h=0.6;
     		netMT->setCharacterHeight(h);
     		if(vlen>1000)
     			netMT->setCaption(networkUsername + "  (" + StringConverter::toString( (float)(ceil(vlen/100)/10.0) )+ " km)");
     		else if (vlen>20 && vlen <= 1000)
     			netMT->setCaption(networkUsername + "  (" + StringConverter::toString((int)vlen)+ " m)");
     		else
     			netMT->setCaption(networkUsername);
     		//netMT->setAdditionalHeight((maxy-miny)+h+0.1);
     		netMT->setVisible(true);
+    	}
+    }
-...
+    }
     void Beam::preMapLabelRenderUpdate(bool mode, float charheight)
+    {
     	static float orgcharheight=0;
     	if(mode && netLabelNode)
+    	{
     		netMT->showOnTop(true);
     		orgcharheight = netMT->getCharacterHeight();
     		netMT->setCharacterHeight(charheight);
     		//netMT->setAdditionalHeight(0);
     		netMT->setVisible(false);
     	} else if(!mode && netLabelNode)
+    	{
     		netMT->showOnTop(false);
     		netMT->setCharacterHeight(orgcharheight);
     		netMT->setVisible(true);
+    	}
+    }
     void Beam::showSkeleton(bool meshes, bool newMode)
+    {
     	if(lockSkeletonchange)
-...
     				sprintf(entName, "%s-nodesDebug-%d-Ent", truckname, i);
     				Entity *b = tsm->createEntity(entName, "beam.mesh");
     				t.id=i;
     				t.txt = new MovableText(nodeName, "n"+StringConverter::toString(i));
     				t.txt->setFontName("highcontrast_black");
     				t.txt->setTextAlignment(MovableText::H_LEFT, MovableText::V_BELOW);
     				//t.txt->setAdditionalHeight(0);
     				t.txt->showOnTop(true);
     				t.txt->setCharacterHeight(0.5);
     				t.txt->setColor(ColourValue::White);
     				t.label = GUI_3DLabelManager::getSingleton().new3DLabel(b, "n"+StringConverter::toString(i), ColourValue::White);
     				t.node = tsm->getRootSceneNode()->createChildSceneNode();
     				t.node->attachObject(t.txt);
     				t.node->attachObject(b);
     				t.node->setScale(Vector3(0.05,0.05,0.05));
-...
     			for(int i=0; i<free_beam; i++)
+    			{
     				debugtext_t t;
     				char nodeName[255]="";
     				char nodeName[255]="", entName[255]="";
     				sprintf(nodeName, "%s-beamsDebug-%d", truckname, i);
     				sprintf(entName, "%s-nodesDebug-%d-Ent", truckname, i);
     				t.id=i;
     				t.txt = new MovableText(nodeName, "b"+StringConverter::toString(i));
     				t.txt->setFontName("highcontrast_black");
     				t.txt->setTextAlignment(MovableText::H_LEFT, MovableText::V_BELOW);
     				//t.txt->setAdditionalHeight(0);
     				t.txt->showOnTop(true);
     				t.txt->setCharacterHeight(1);
     				t.txt->setColor(ColourValue::White);
     				Entity *b = tsm->createEntity(entName, "beam.mesh");
     				t.label = GUI_3DLabelManager::getSingleton().new3DLabel(b, "b"+StringConverter::toString(i), ColourValue::White);
     				t.node = tsm->getRootSceneNode()->createChildSceneNode();
     				t.node->attachObject(t.txt);
     				t.node->attachObject(b);
     				Vector3 pos = beams[i].p1->smoothpos - (beams[i].p1->smoothpos - beams[i].p2->smoothpos)/2;
     				t.node->setPosition(pos);
-...
     		for(std::vector<debugtext_t>::iterator it=nodes_debug.begin(); it!=nodes_debug.end();it++)
+    		{
     			it->node->setPosition(nodes[it->id].smoothpos);
     			it->txt->setCaption(StringConverter::toString(nodes[it->id].mass));
     			it->label->setCaption(StringConverter::toString(nodes[it->id].mass));
+    		}
     		break;
     	case 5: // node-locked
     		for(std::vector<debugtext_t>::iterator it=nodes_debug.begin(); it!=nodes_debug.end();it++)
+    		{
     			it->txt->setCaption((nodes[it->id].locked)?"locked":"unlocked");
     			it->label->setCaption((nodes[it->id].locked)?"locked":"unlocked");
     			it->node->setPosition(nodes[it->id].smoothpos);
+    		}
     		break;
-...
+    		{
     			it->node->setPosition(beams[it->id].p1->smoothpos - (beams[it->id].p1->smoothpos - beams[it->id].p2->smoothpos)/2);
     			int scale=(int)(beams[it->id].scale * 100);
     			it->txt->setCaption(StringConverter::toString(scale));
     			it->label->setCaption(StringConverter::toString(scale));
+    		}
     		break;
     	case 7: // beam-broken
     		for(std::vector<debugtext_t>::iterator it=beams_debug.begin(); it!=beams_debug.end();it++)
+    		{
     			it->node->setPosition(beams[it->id].p1->smoothpos - (beams[it->id].p1->smoothpos - beams[it->id].p2->smoothpos)/2);
     			it->txt->setCaption((beams[it->id].broken)?"BROKEN":"");
     			it->label->setCaption((beams[it->id].broken)?"BROKEN":"");
+    		}
     		break;
     	case 8: // beam-stress
     		for(std::vector<debugtext_t>::iterator it=beams_debug.begin(); it!=beams_debug.end();it++)
+    		{
     			it->node->setPosition(beams[it->id].p1->smoothpos - (beams[it->id].p1->smoothpos - beams[it->id].p2->smoothpos)/2);
     			it->txt->setCaption(StringConverter::toString((float) fabs(beams[it->id].stress)));
     			it->label->setCaption(StringConverter::toString((float) fabs(beams[it->id].stress)));
+    		}
     		break;
     	case 9: // beam-strength
     		for(std::vector<debugtext_t>::iterator it=beams_debug.begin(); it!=beams_debug.end();it++)
+    		{
     			it->node->setPosition(beams[it->id].p1->smoothpos - (beams[it->id].p1->smoothpos - beams[it->id].p2->smoothpos)/2);
     			it->txt->setCaption(StringConverter::toString(beams[it->id].strength));
     			it->label->setCaption(StringConverter::toString(beams[it->id].strength));
+    		}
     		break;
     	case 10: // beam-hydros
-...
+    		{
     			it->node->setPosition(beams[it->id].p1->smoothpos - (beams[it->id].p1->smoothpos - beams[it->id].p2->smoothpos)/2);
     			int v = (beams[it->id].L / beams[it->id].Lhydro) * 100;
     			it->txt->setCaption(StringConverter::toString(v));
     			it->label->setCaption(StringConverter::toString(v));
+    		}
     		break;
     	case 11: // beam-commands
-...
+    		{
     			it->node->setPosition(beams[it->id].p1->smoothpos - (beams[it->id].p1->smoothpos - beams[it->id].p2->smoothpos)/2);
     			int v = (beams[it->id].L / beams[it->id].commandLong) * 100;
     			it->txt->setCaption(StringConverter::toString(v));
     			it->label->setCaption(StringConverter::toString(v));
+    		}
     		break;
+    	}
-...
     void Beam::updateNetworkInfo()
+    {
     #ifdef USE_SOCKETW
     #ifdef USE_MYGUI
     	if(!net) return;
     	bool remote = (state == NETWORKED);
     	user_info_t *info = 0;
     	if(remote)
+    	{
     		client_t *c = net->getClientInfo(sourceid);
     		if(!c) return;
     		networkUsername = String(c->user.username);
     		networkAuthlevel = c->user.authstatus;
     	} else
+    	{
     		user_info_t *info = net->getLocalUserData();
     		if(!info) return;
     		if(!strlen(info->username)) return;
     		networkUsername = String(info->username);
     		networkAuthlevel = info->authstatus;
+    	}
     		info = &(net->getClientInfo(sourceid)->user);
     	else
     		info = net->getLocalUserData();
     	if (netLabelNode && netMT)
     	if(!info) return;
     	if(!strlen(info->username)) return;
     	networkUsername = String(info->username);
     	networkAuthlevel = info->authstatus;
     	int colourNum = info->colournum;
     	if (!netLabel)
+    	{
     		// ha, this caused the empty caption bug, but fixed now since we change the caption if its empty:
     		netMT->setCaption(networkUsername);
     		if(networkAuthlevel & AUTH_ADMIN)
+    		{
     			netMT->setFontName("highcontrast_red");
     		} else if(networkAuthlevel & AUTH_RANKED)
+    		{
     			netMT->setFontName("highcontrast_green");
     		} else
+    		{
     			netMT->setFontName("highcontrast_black");
+    		}
     		netLabelNode->setVisible(true);
     		Ogre::AxisAlignedBox bbox(minx, miny, minz,maxx,maxy,maxz);
     		netLabel = GUI_3DLabelManager::getSingleton().new3DLabel(bbox, ColoredTextAreaOverlayElement::StripColors(networkUsername));
+    	}
     	else
+    	{
     		char wname[256];
     		sprintf(wname, "netlabel-%s",truckname);
     		netMT = new MovableText(wname, ColoredTextAreaOverlayElement::StripColors(networkUsername));
     		netMT->setFontName("highcontrast_black");
     		netMT->setTextAlignment(MovableText::H_CENTER, MovableText::V_ABOVE);
     		//netMT->setAdditionalHeight(2);
     		netMT->showOnTop(false);
     		netMT->setCharacterHeight(2);
     		netMT->setColor(ColourValue::White);
     		if(networkAuthlevel & AUTH_ADMIN)
+    		{
     			netMT->setFontName("highcontrast_red");
     		} else if(networkAuthlevel & AUTH_RANKED)
+    		{
     			netMT->setFontName("highcontrast_green");
     		} else
+    		{
     			netMT->setFontName("highcontrast_black");
+    		}
     	netLabel->setTextColour(PlayerColours::getSingleton().getColour(colourNum));
     	netLabel->setCaption(ColoredTextAreaOverlayElement::StripColors(networkUsername));
     	netLabel->setVisible(true);
     		netLabelNode=parentNode->createChildSceneNode();
     		netLabelNode->attachObject(netMT);
     		netLabelNode->setPosition(position);
     		netLabelNode->setVisible(true);
     		deletion_sceneNodes.push_back(netLabelNode);
     		deletion_Objects.push_back(netMT);
+    	}
     #endif //USE_MYGUI
     #endif //SOCKETW
+    }
-...
+    {
     	//park and recycle vehicle
     	state=RECYCLE;
     	if(netMT)
     		netMT->setCaption("");
     	if(netLabel)
+    	{
     		netLabel->setCaption("");
     		netLabel->setVisible(false);
     		// TODO: remove label
+    	}
     	resetPosition(100000, 100000, false, 100000);
     	netLabelNode->setVisible(false);
+    }
     void *threadstart(void* vid)

     	int first_wheel_node;
     	int netbuffersize;
     	int nodebuffersize;
     	SceneNode *netLabelNode;
     	std::string getTruckName();
     	std::vector<authorinfo_t> getAuthors();
-...
     	float getHeadingDirectionAngle();
     	bool getCustomParticleMode();
     	int getLowestNode();
     	void preMapLabelRenderUpdate(bool mode, float cheight=0);
     	SceneNode *cablightNode;
     	float tdt;
-...
     	Timer *nettimer;
     	int net_toffset;
     	int netcounter;
     	MovableText *netMT; //, *netDist;
     	GUI_3DLabel *netLabel;
     	float minimass;
     	// network properties

     struct debugtext
+    {
     	int id;
     	Ogre::MovableText *txt;
     	GUI_3DLabel *label;
     	Ogre::SceneNode *node;
     };

     #include "NetworkStreamManager.h"
     #include "BeamFactory.h"
     #include "ColoredTextAreaOverlayElement.h"
     #include "gui_3dlabels.h"
     #include "PlayerColours.h"
     using namespace Ogre;
-...
     	beamCoupling=0;
     	//remote = true;
     	last_net_time=0;
     	netMT=0;
     	networkUsername = String();
     	networkAuthLevel = 0;
-...
     Character::~Character()
+    {
     	setVisible(false);
     	if(netMT) delete netMT;
     	if(label) GUI_3DLabelManager::getSingleton().remove3DLabel(label);
     	if(personode) personode->detachAllObjects();
     #ifdef USE_MYGUI
     	if(map && mapEnt) map->deleteMapEntity(mapEnt);
-...
+    	}
     	//LogManager::getSingleton().logMessage(" * updateNetLabel : " + StringConverter::toString(this->source));
     	if(!netMT)
+    	{
     		netMT = new MovableText("netlabel-"+myName, ColoredTextAreaOverlayElement::StripColors(networkUsername));
     		personode->attachObject(netMT);
     		netMT->setFontName("highcontrast_black");
     		netMT->setTextAlignment(MovableText::H_CENTER, MovableText::V_ABOVE);
     		netMT->setAdditionalHeight(2);
     		netMT->showOnTop(false);
     		netMT->setCharacterHeight(8);
     		netMT->setColor(ColourValue::White);
+    	}
     	if(!label)
     		label = GUI_3DLabelManager::getSingleton().new3DLabel(personode->getAttachedObject(0), ColoredTextAreaOverlayElement::StripColors(networkUsername));
     	//LogManager::getSingleton().logMessage(" *label caption: " + String(networkUsername));
     	//LogManager::getSingleton().logMessage(" *label caption: " + ColoredTextAreaOverlayElement::StripColors(networkUsername));
     	netMT->setCaption(ColoredTextAreaOverlayElement::StripColors(networkUsername));
     	if(networkAuthLevel & AUTH_ADMIN)
+    	{
     		netMT->setFontName("highcontrast_red");
     	} else if(networkAuthLevel & AUTH_RANKED)
+    	{
     		netMT->setFontName("highcontrast_green");
     	} else
+    	{
     		netMT->setFontName("highcontrast_black");
+    	}
     	label->setCaption(ColoredTextAreaOverlayElement::StripColors(networkUsername));
     	label->setTextColour(PlayerColours::getSingleton().getColour(colourNumber));
     	// update character colour
     	updateCharacterColour();
-...
     void Character::updateNetLabelSize()
+    {
     	if (!this || !net || !netMT || !netMT->isVisible()) return;
     	if (!this || !net || !label || !label->getVisible()) return;
     	Vector3 vdir = personode->getPosition() - mCamera->getPosition();
     	float vlen=vdir.length();
     	/*
     	float h = vlen * 1.2f;
     	if(h<9)
     		h=9;
     	netMT->setCharacterHeight(h);
     	label->setHeight(h);
     	*/
     	if(vlen>1000)
     		netMT->setCaption(networkUsername + "  (" + StringConverter::toString( (float)(ceil(vlen/100)/10.0) )+ " km)");
     		label->setCaption(networkUsername + "  (" + StringConverter::toString( (float)(ceil(vlen/100)/10.0) )+ " km)");
     	else if (vlen>20 && vlen <= 1000)
     		netMT->setCaption(networkUsername + "  (" + StringConverter::toString((int)vlen)+ " m)");
     		label->setCaption(networkUsername + "  (" + StringConverter::toString((int)vlen)+ " m)");
     	else
     		netMT->setCaption(networkUsername);
     		label->setCaption(networkUsername);
     	//netMT->setAdditionalHeight((maxy-miny)+h+0.1);
     	netMT->setVisible(true);
     	label->setVisible(true);
+    }
     int Character::setBeamCoupling(bool enabled, Beam *truck)
-...
     		if(!truck) return 1;
     		beamCoupling = truck;
     		setPhysicsEnabled(false);
     		if(netMT && netMT->isVisible()) netMT->setVisible(false);
     		if(label && label->getVisible()) label->setVisible(false);
     		if(net && !remote)
+    		{
     			attach_netdata_t data;
-...
+    	{
     		setPhysicsEnabled(true);
     		beamCoupling=0;
     		if(netMT && !netMT->isVisible()) netMT->setVisible(true);
     		if(label && !label->getVisible()) label->setVisible(true);
     		if(net && !remote)
+    		{
     			attach_netdata_t data;

     #include <Ogre.h>
     #include <OgreVector3.h>
     #include "Streamable.h"
     #include "MovableText.h"
     #include "gui_3dlabels.h"
     #include "rormemory.h"
     class Water;
-...
     	bool remote;
     	bool physicsEnabled;
     	int colourNumber;
     	Ogre::MovableText *netMT;
     	GUI_3DLabel *label;
     	MapEntity *mapEnt;
     	Ogre::String networkUsername;
     	int networkAuthLevel;

     #include <Ogre.h>
     #include <OgreVector3.h>
     #include "Streamable.h"
     #include "MovableText.h"
     #include "gui_3dlabels.h"
     #include "StreamableFactory.h"
     #include "IngameConsole.h"
     #include "rormemory.h"

     #include "Landusemap.h"
     #include "approxmath.h"
     #include "errorutils.h"
     #include "gui_3dlabels.h"
     #include "language.h"
     // some gcc fixes
-...
     				// setup the label
     				String labelName = "label_"+cell_name;
     				String labelCaption = cell_name+" "+StringConverter::toString(percent*100,2) + "% usage ("+StringConverter::toString(cc)+"/"+StringConverter::toString(CELL_BLOCKSIZE)+") DEEP: " + StringConverter::toString(deep);
     				MovableText *mt = new MovableText(labelName, labelCaption);
     				mt->setFontName("highcontrast_black");
     				mt->setTextAlignment(MovableText::H_CENTER, MovableText::V_ABOVE);
     				mt->setAdditionalHeight(1);
     				mt->showOnTop(false);
     				mt->setCharacterHeight(0.3);
     				mt->setColor(ColourValue::White);
     				mo_node->attachObject(mt);
     				GUI_3DLabel *label = GUI_3DLabelManager::getSingleton().new3DLabel(mo, labelCaption);
     				label->setMaxDistance(50);
     				label->setLineHeight(8);
     				label->setAbove(false);
     				mo_node->setVisible(true);
     				mo_node->setPosition(Vector3(x+CELL_SIZE/(float)2.0, groundheight, z+CELL_SIZE/(float)2.0));
+    			}

     /*
     This source file is part of Rigs of Rods
     Copyright 2005,2006,2007,2008,2009 Pierre-Michel Ricordel
     Copyright 2007,2008,2009 Thomas Fischer
     For more information, see http://www.rigsofrods.com/
     Rigs of Rods is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License version 3, as
     published by the Free Software Foundation.
     Rigs of Rods is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with Rigs of Rods.  If not, see <http://www.gnu.org/licenses/>.
     */
     // created by Thomas Fischer thomas{AT}thomasfischer{DOT}biz, 28th of July 2010
     #ifdef USE_MYGUI
     #include "gui_3dlabels.h"
     #include "gui_manager.h"
     #include "Settings.h"
     #include "language.h"
     #include "RoRFrameListener.h"
     #include "network.h"
     #include "PlayerColours.h"
     #include "BeamFactory.h"
     #include "CharacterFactory.h"
     template<> GUI_3DLabelManager * Singleton< GUI_3DLabelManager >::ms_Singleton = 0;
     GUI_3DLabelManager* GUI_3DLabelManager::getSingletonPtr(void)
+    {
     	return ms_Singleton;
+    }
     GUI_3DLabelManager& GUI_3DLabelManager::getSingleton(void)
+    {
     	assert( ms_Singleton );  return ( *ms_Singleton );
+    }
     GUI_3DLabelManager::GUI_3DLabelManager(Ogre::Camera *cam) : mCamera(cam)
+    {
     	MyGUI::IntSize gui_area = GUIManager::getSingleton().getGUI()->getViewSize();
     	parentWindow = MyGUI::Gui::getInstance().createWidget<MyGUI::Window>("FlowContainer", 0, 0, gui_area.width, gui_area.height,  MyGUI::Align::Default, "Main");
     	parentWindow->setVisible(true);
+    }
     GUI_3DLabelManager::~GUI_3DLabelManager()
+    {
+    }
     void GUI_3DLabelManager::update(float dt)
+    {
     	std::vector<GUI_3DLabel *>::iterator it;
     	for(it = labels.begin(); it != labels.end(); it++)
+    	{
     		GUI_3DLabel *label = (*it);
     		MovableObject *obj = label->getObject();
     		int labelMode = label->getMode();
     		Ogre::Real min_x, max_x, min_y, max_y;
     		if(labelMode == GUI_3DLabel::LBLMODE_OBJ)
     			getMinMaxEdgesOfTopAABBIn2D(obj, min_x, min_y, max_x, max_y);
     		else if(labelMode == GUI_3DLabel::LBLMODE_BB)
     			getMinMaxEdgesOfTopAABBIn2D(label->getBoundingBox(), min_x, min_y, max_x, max_y);
     		// TODO: implement GUI_3DLabel::LBLMODE_NODE
     		// check if this label is distance limited
     		if(label->getMaxDistance() > 0 && labelMode == GUI_3DLabel::LBLMODE_OBJ)
+    		{
     			Ogre::SceneNode *sn = obj->getParentSceneNode();
     			if(!sn) continue;
     			float distance = (sn->getPosition() - mCamera->getPosition()).length();
     			float vis = distance / label->getMaxDistance();
     			if(vis > 1)
+    			{
     				// too far away, not visible
     				label->_setVisible(false);
     				continue;
     			} else
+    			{
     				// visible, but fade out
     				//label->setAlpha(1 - vis);
+    			}
+    		}
     		// get the width of the bar
     		MyGUI::IntSize gui_area = GUIManager::getSingleton().getGUI()->getViewSize();
     		Real relTextWidth = (float)label->_getWidth() / (float)gui_area.width;
     		Real relTextHeight = (float)label->_getHeight() / (float)gui_area.height;
     		// improved on screen check
     		bool onScreen = false;
     		if (
     			(min_x > -relTextWidth)
     			&& (max_x < 1.0 + relTextWidth)
     			&& (min_y > 0.0 - relTextHeight)
     			&& (max_y < 1.0 + relTextHeight)
+    			)
     		   onScreen = true;
     		// hide label if wished
     		if(!label->_getShown())
     			onScreen=false;
     		if(!onScreen)
+    		{
     			label->_setVisible(false);
     			continue;
+    		}
     		label->_setVisible(true);
     		if(label->getAbove())
+    		{
     			label->_setPosition(MyGUI::IntPoint(
     				(1-(min_x + max_x + relTextWidth)/2) * gui_area.width,
     				(1-max_y) * gui_area.height - label->_getHeight()
     				));
     		} else
+    		{
     			label->_setPosition(MyGUI::IntPoint(
     				(1-(min_x + max_x + relTextWidth)/2) * gui_area.width,
     				(1-max_y) * gui_area.height
     				));
+    		}
+    	}
+    }
     void GUI_3DLabelManager::setVisible(bool value)
+    {
     	parentWindow->setVisible(value);
+    }
     bool GUI_3DLabelManager::getVisible()
+    {
     	return parentWindow->isVisible();
+    }
     void GUI_3DLabelManager::getMinMaxEdgesOfTopAABBIn2D(const Ogre::MovableObject *mov, Ogre::Real& MinX, Ogre::Real& MinY, Ogre::Real& MaxX, Ogre::Real& MaxY)
+    {
     	if (!mov->isInScene())
     	   return;
     	const Ogre::AxisAlignedBox &AABB = mov->getWorldBoundingBox(true);// the AABB of the target
     	getMinMaxEdgesOfTopAABBIn2D(AABB, MinX, MinY, MaxX, MaxY);
+    }
     void GUI_3DLabelManager::getMinMaxEdgesOfTopAABBIn2D(const Ogre::AxisAlignedBox &AABB, Ogre::Real& MinX, Ogre::Real& MinY, Ogre::Real& MaxX, Ogre::Real& MaxY)
+    {
     	MinX = 0;
     	MinY = 0;
     	MaxX = 0;
     	MaxY = 0;
     	Ogre::Real X[4];// the 2D dots of the AABB in screencoordinates
     	Ogre::Real Y[4];
     	const Ogre::Vector3 CornersOfTopAABB[4] = {	AABB.getCorner(AxisAlignedBox::FAR_LEFT_TOP),
     										AABB.getCorner(AxisAlignedBox::FAR_RIGHT_TOP),
     										AABB.getCorner(AxisAlignedBox::NEAR_LEFT_TOP),
     										AABB.getCorner(AxisAlignedBox::NEAR_RIGHT_TOP)};
     	Ogre::Vector3 CameraPlainNormal = mCamera->getDerivedOrientation().zAxis();//The normal vector of the plaine.this points directly infront of the cam
     	Ogre::Plane CameraPlain = Plane(CameraPlainNormal,mCamera->getDerivedPosition());//the plaine that devides the space bevor and behin the cam
     	for (int i = 0; i < 4; i++)
+    	{
     	  X[i] = 0;
     	  Y[i] = 0;
     	  getScreenCoordinates(CornersOfTopAABB[i],X[i],Y[i]);// transfor into 2d dots
     	  if (CameraPlain.getSide(CornersOfTopAABB[i]) == Plane::NEGATIVE_SIDE)
+    	  {
     		 if (i == 0)// accept the first set of values, no matter how bad it might be.
+    		 {
     			MinX = X[i];
     			MinY = Y[i];
     			MaxX = X[i];
     			MaxY = Y[i];
+    		 }
     		 else// now compare if you get "better" values
+    		 {
     			if (MinX > X[i])// get the x minimum
+    			{
     			   MinX = X[i];
+    			}
     			if (MinY > Y[i])// get the y minimum
+    			{
     			   MinY = Y[i];
+    			}
     			if (MaxX < X[i])// get the x maximum
+    			{
     			   MaxX = X[i];
+    			}
     			if (MaxY < Y[i])// get the y maximum
+    			{
     			   MaxY = Y[i];
+    			}
+    		 }
+    	  }
     	  else
+    	  {
     		MinX = 0;
     		MinY = 0;
     		MaxX = 0;
     		MaxY = 0;
     		break;
+    	  }
+    	}
+    }
     void GUI_3DLabelManager::getScreenCoordinates(const Ogre::Vector3& position, Ogre::Real& x, Ogre::Real& y)
+    {
     	Vector3 hcsPosition = mCamera->getProjectionMatrix() * (mCamera->getViewMatrix() * position);
     	x = 1.0f - ((hcsPosition.x * 0.5f) + 0.5f);// 0 <= x <= 1 // left := 0,right := 1
     	y = ((hcsPosition.y * 0.5f) + 0.5f);// 0 <= y <= 1 // bottom := 0,top := 1
+    }
     GUI_3DLabel *GUI_3DLabelManager::new3DLabel(Ogre::MovableObject *obj, Ogre::String text, Ogre::ColourValue textColour)
+    {
     	GUI_3DLabel *l = new GUI_3DLabel(parentWindow, obj, text, textColour);
     	labels.push_back(l);
     	return l;
+    }
     GUI_3DLabel *GUI_3DLabelManager::new3DLabel(Ogre::SceneNode *node, Ogre::String text, Ogre::ColourValue textColour)
+    {
     	GUI_3DLabel *l = new GUI_3DLabel(parentWindow, node, text, textColour);
     	labels.push_back(l);
     	return l;
+    }
     GUI_3DLabel *GUI_3DLabelManager::new3DLabel(Ogre::AxisAlignedBox bbox, Ogre::String text, Ogre::ColourValue textColour)
+    {
     	GUI_3DLabel *l = new GUI_3DLabel(parentWindow, bbox, text, textColour);
     	labels.push_back(l);
     	return l;
+    }
     void GUI_3DLabelManager::remove3DLabel(GUI_3DLabel *lbl)
+    {
     	// TODO
+    }
     #endif // USE_MYGUI

     /*
     This source file is part of Rigs of Rods
     Copyright 2005,2006,2007,2008,2009 Pierre-Michel Ricordel
     Copyright 2007,2008,2009 Thomas Fischer
     For more information, see http://www.rigsofrods.com/
     Rigs of Rods is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License version 3, as
     published by the Free Software Foundation.
     Rigs of Rods is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with Rigs of Rods.  If not, see <http://www.gnu.org/licenses/>.
     */
     // created by Thomas Fischer thomas{AT}thomasfischer{DOT}biz, 28th of July 2010
     #ifdef USE_MYGUI
     #ifndef GUI_3DLABELS_H__
     #define GUI_3DLABELS_H__
     #include <MyGUI.h>
     #include "OgreSingleton.h"
     #include "OgrePrerequisites.h"
     #include "OgreColourValue.h"
     #include "Beam.h"
     class GUI_3DLabel : public MemoryAllocatedObject
+    {
     	friend class GUI_3DLabelManager;
     protected:
     	MyGUI::WindowPtr parentWindow;
     	Ogre::SceneNode *node;
     	Ogre::MovableObject  *obj;
     	Ogre::ColourValue colour;
     	Ogre::String txt;
     	bool shown;
     	Ogre::AxisAlignedBox bounding_box;
     	float maxDist;
     	bool above;
     	float lineheight;
     	enum {LBLMODE_ERR, LBLMODE_OBJ, LBLMODE_BB, LBLMODE_NODE};
     	MyGUI::StaticImagePtr background;
     	MyGUI::StaticTextPtr  text;
     	GUI_3DLabel(MyGUI::WindowPtr _parentWindow, Ogre::MovableObject *_obj, Ogre::String _txt, Ogre::ColourValue _colour) : parentWindow(_parentWindow), node(0), obj(_obj), colour(_colour), txt(_txt), shown(true), bounding_box(Ogre::AxisAlignedBox::BOX_NULL), maxDist(-1), above(true), lineheight(16)
+    	{
     		createGUI();
+    	}
     	GUI_3DLabel(MyGUI::WindowPtr _parentWindow, Ogre::SceneNode *_node, Ogre::String _txt, Ogre::ColourValue _colour) : parentWindow(_parentWindow), node(_node), obj(0), colour(_colour), txt(_txt), shown(true), bounding_box(Ogre::AxisAlignedBox::BOX_NULL), maxDist(-1), above(true), lineheight(16)
+    	{
     		createGUI();
+    	}
     	GUI_3DLabel(MyGUI::WindowPtr _parentWindow, Ogre::AxisAlignedBox bbox, Ogre::String _txt, Ogre::ColourValue _colour) : parentWindow(_parentWindow), node(0), obj(0), colour(_colour), txt(_txt), shown(true), bounding_box(bbox), maxDist(-1), above(true), lineheight(16)
+    	{
     		createGUI();
+    	}
     	int getMode()
+    	{
     		if(obj)
     			return LBLMODE_OBJ;
     		else if(!obj && bounding_box != Ogre::AxisAlignedBox::BOX_NULL)
     			return LBLMODE_BB;
     		else if(!obj && bounding_box == Ogre::AxisAlignedBox::BOX_NULL && node)
     			return LBLMODE_NODE;
     		return LBLMODE_ERR;
+    	}
     	void createGUI()
+    	{
     		background = parentWindow->createWidget<MyGUI::StaticImage>("StaticImage", 0, 0, 200, lineheight+2,  MyGUI::Align::Default, "Main");
     		background->setImageTexture("mpbg.png");
     		text = background->createWidget<MyGUI::StaticText>("StaticText", 2, 2, 200, lineheight,  MyGUI::Align::Default, "helptext");
     		text->setCaption(txt);
     		text->setFontName("VeraMoBd");
     		text->setTextColour(MyGUI::Colour(colour.r,colour.g,colour.b,colour.a));
     		text->setFontHeight(lineheight);
+    	}
     	~GUI_3DLabel()
+    	{
+    	}
     	MovableObject *getObject()
+    	{
     		return obj;
+    	}
     	Ogre::SceneNode *getNode()
+    	{
     		return node;
+    	}
     	void _setVisible(bool value)
+    	{
     		background->setVisible(value);
+    	}
     	bool _getVisible()
+    	{
     		return background->isVisible();
+    	}
     	bool _getShown()
+    	{
     		return shown;
+    	}
     	void _setPosition(MyGUI::IntPoint p)
+    	{
     		background->setPosition(p);
+    	}
     	float _getHeight()
+    	{
     		return background->getHeight();
+    	}
     	float _getWidth()
+    	{
     		return background->getWidth();
+    	}
     public:
     	void setVisible(bool value)
+    	{
     		shown = value;
+    	}
     	bool getVisible()
+    	{
     		return shown;
+    	}
     	void setCaption(Ogre::String _txt)
+    	{
     		txt = _txt;
     		text->setCaption(txt);
+    	}
     	void setMaxDistance(float dist)
+    	{
     		maxDist = dist;
+    	}
     	void setLineHeight(float val)
+    	{
     		lineheight = val;
     		background->setSize(background->getWidth(), lineheight);
     		text->setSize(text->getWidth(), lineheight);
     		text->setFontHeight(lineheight);
+    	}
     	float getMaxDistance()
+    	{
     		return maxDist;
+    	}
     	void setAlpha(float a)
+    	{
     		background->setAlpha(a);
+    	}
     	float getAlpha()
+    	{
     		return background->getAlpha();
+    	}
     	void setAbove(bool value)
+    	{
     		above=value;
+    	}
     	bool getAbove()
+    	{
     		return above;
+    	}
     	void setTextColour(Ogre::ColourValue col)
+    	{
     		this->colour = col;
     		text->setTextColour(MyGUI::Colour(colour.r,colour.g,colour.b,colour.a));
+    	}
     	Ogre::AxisAlignedBox getBoundingBox()
+    	{
     		return bounding_box;
+    	}
     	void setBoundingBox(Ogre::AxisAlignedBox b)
+    	{
     		bounding_box = b;
+    	}
     };
     class GUI_3DLabelManager : public Ogre::Singleton< GUI_3DLabelManager >, public MemoryAllocatedObject
+    {
     public:
     	GUI_3DLabelManager(Ogre::Camera *mCamera);
     	~GUI_3DLabelManager();
     	static GUI_3DLabelManager& getSingleton(void);
     	static GUI_3DLabelManager* getSingletonPtr(void);
     	void setVisible(bool value);
     	bool getVisible();
     	void update(float dt);
     	GUI_3DLabel *new3DLabel(Ogre::MovableObject *mov, Ogre::String text, Ogre::ColourValue textColour = Ogre::ColourValue::Black);
     	GUI_3DLabel *new3DLabel(Ogre::SceneNode *node, Ogre::String text, Ogre::ColourValue textColour = Ogre::ColourValue::Black);
     	GUI_3DLabel *new3DLabel(Ogre::AxisAlignedBox bbox, Ogre::String text, Ogre::ColourValue textColour = Ogre::ColourValue::Black);
     	void remove3DLabel(GUI_3DLabel *lbl);
     protected:
     	Ogre::Camera *mCamera;
     	MyGUI::WindowPtr parentWindow;
     	void getMinMaxEdgesOfTopAABBIn2D(const Ogre::MovableObject *mov, Ogre::Real& MinX, Ogre::Real& MinY, Ogre::Real& MaxX, Ogre::Real& MaxY);
     	void getMinMaxEdgesOfTopAABBIn2D(const Ogre::AxisAlignedBox &AABB, Ogre::Real& MinX, Ogre::Real& MinY, Ogre::Real& MaxX, Ogre::Real& MaxY);
     	void getScreenCoordinates(const Ogre::Vector3& position, Ogre::Real& x, Ogre::Real& y);
     	std::vector<GUI_3DLabel *> labels;
     };
     #endif //GUI_3DLABELS_H__
     #else // USE_MYGUI
     class GUI_3DLabel
+    {
     };
     #endif // USE_MYGUI

     /**
     * File: MovableText.cpp
+    *
     * description: This create create a billboarding object that display a text.
+    *
     * @author  2003 by cTh see gavocanov@rambler.ru
     * @update  2006 by barraq see nospam@barraquand.com
     */
     #include "Ogre.h"
     #include "OgreFontManager.h"
     #include "MovableText.h"
     #include "rormemory.h"
     using namespace Ogre;
     #define POS_TEX_BINDING    0
     #define COLOUR_BINDING     1
     MovableText::MovableText(const String &name, const String &caption, const String &fontName, Real charHeight, const ColourValue &color)
     : mpCam(NULL)
     , mpWin(NULL)
     , mpFont(NULL)
     , mName(name)
     , mCaption(caption)
     , mFontName(fontName)
     , mCharHeight(charHeight)
     , mColor(color)
     , mType("MovableText")
     , mTimeUntilNextToggle(0)
     , mSpaceWidth(0)
     , mUpdateColors(true)
     , mOnTop(false)
     , mHorizontalAlignment(H_LEFT)
     , mVerticalAlignment(V_BELOW)
     , mAdditionalHeight(0.0)
+    {
     	if (name == "")
     		throw Exception(Exception::ERR_INVALIDPARAMS, "Trying to create MovableText without name", "MovableText::MovableText");
     	if (caption == "")
     	//    throw Exception(Exception::ERR_INVALIDPARAMS, "Trying to create MovableText without caption", "MovableText::MovableText");
     		mCaption = ".";
     	mRenderOp.vertexData = NULL;
     	this->setFontName(mFontName);
     	this->_setupGeometry();
+    }
     MovableText::~MovableText()
+    {
     	if (mRenderOp.vertexData)
     		delete mRenderOp.vertexData;
+    }
     void MovableText::setFontName(const String &fontName)
+    {
     	if((Ogre::MaterialManager::getSingletonPtr()->resourceExists(mName + "Material")))
+    	{
     		Ogre::MaterialManager::getSingleton().remove(mName + "Material");
+    	}
     	if (mFontName != fontName || mpMaterial.isNull() || !mpFont)
+    	{
     		mFontName = fontName;
     		mpFont = (Font *)FontManager::getSingleton().getByName(mFontName).getPointer();
     		if (!mpFont)
     			throw Exception(Exception::ERR_ITEM_NOT_FOUND, "Could not find font " + fontName, "MovableText::setFontName");
     		mpFont->load();
     		if (!mpMaterial.isNull())
+    		{
     			MaterialManager::getSingletonPtr()->remove(mpMaterial->getName());
     			mpMaterial.setNull();
+    		}
     		mpMaterial = mpFont->getMaterial()->clone(mName + "Material");
     		if (!mpMaterial->isLoaded())
     			mpMaterial->load();
     		mpMaterial->setDepthCheckEnabled(!mOnTop);
     		mpMaterial->setDepthBias(1.0,1.0);
     		mpMaterial->setFog(true);
     		mpMaterial->setDepthWriteEnabled(mOnTop);
     		mpMaterial->setLightingEnabled(false);
     		mNeedUpdate = true;
+    	}
+    }
     void MovableText::setCaption(const String &caption)
+    {
     	if (caption != mCaption)
+    	{
     		mCaption = caption;
     		mNeedUpdate = true;
+    	}
+    }
     void MovableText::setColor(const ColourValue &color)
+    {
     	if (color != mColor)
+    	{
     		mColor = color;
     		mUpdateColors = true;
+    	}
+    }
     void MovableText::setCharacterHeight(Real height)
+    {
     	if (fabs(height - mCharHeight) > 0.00001f)
+    	{
     		mCharHeight = height;
     		mNeedUpdate = true;
+    	}
+    }
     void MovableText::setSpaceWidth(Real width)
+    {
     	if (fabs(width - mSpaceWidth) > 0.00001f)
+    	{
     		mSpaceWidth = width;
     		mNeedUpdate = true;
+    	}
+    }
     void MovableText::setTextAlignment(const HorizontalAlignment& horizontalAlignment, const VerticalAlignment& verticalAlignment)
+    {
     	if(mHorizontalAlignment != horizontalAlignment)
+    	{
     		mHorizontalAlignment = horizontalAlignment;
     		mNeedUpdate = true;
+    	}
     	if(mVerticalAlignment != verticalAlignment)
+    	{
     		mVerticalAlignment = verticalAlignment;
     		mNeedUpdate = true;
+    	}
+    }
     void MovableText::setAdditionalHeight( Real height )
+    {
     	if (fabs(mAdditionalHeight - height) > 0.00001f)
+    	{
     		mAdditionalHeight = height;
     		mNeedUpdate = true;
+    	}
+    }
     void MovableText::showOnTop(bool show)
+    {
     	if( mOnTop != show && !mpMaterial.isNull() )
+    	{
     		mOnTop = show;
     		mpMaterial->setDepthBias(1.0,1.0);
     		mpMaterial->setDepthCheckEnabled(!mOnTop);
     		mpMaterial->setDepthWriteEnabled(mOnTop);
+    	}
+    }
     void MovableText::_setupGeometry()
+    {
     	assert(mpFont);
     	assert(!mpMaterial.isNull());
     	uint vertexCount = static_cast<uint>(mCaption.size() * 6);
     	if (mRenderOp.vertexData)
+    	{
     		// Removed this test as it causes problems when replacing a caption
     		// of the same size: replacing "Hello" with "hello"
     		// as well as when changing the text alignment
     		//if (mRenderOp.vertexData->vertexCount != vertexCount)
+    		{
     			delete mRenderOp.vertexData;
     			mRenderOp.vertexData = NULL;
     			mUpdateColors = true;
+    		}
+    	}
     	if (!mRenderOp.vertexData)
     		mRenderOp.vertexData = new VertexData();
     	mRenderOp.indexData = 0;
     	mRenderOp.vertexData->vertexStart = 0;
     	mRenderOp.vertexData->vertexCount = vertexCount;
     	mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
     	mRenderOp.useIndexes = false;
     	VertexDeclaration  *decl = mRenderOp.vertexData->vertexDeclaration;
     	VertexBufferBinding   *bind = mRenderOp.vertexData->vertexBufferBinding;
     	size_t offset = 0;
     	// create/bind positions/tex.ccord. buffer
     	if (!decl->findElementBySemantic(VES_POSITION))
     		decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION);
     	offset += VertexElement::getTypeSize(VET_FLOAT3);
     	if (!decl->findElementBySemantic(VES_TEXTURE_COORDINATES))
     		decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
     	HardwareVertexBufferSharedPtr ptbuf = HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(POS_TEX_BINDING),
     		mRenderOp.vertexData->vertexCount,
     		HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
     	bind->setBinding(POS_TEX_BINDING, ptbuf);
     	// Colours - store these in a separate buffer because they change less often
     	if (!decl->findElementBySemantic(VES_DIFFUSE))
     		decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
     	HardwareVertexBufferSharedPtr cbuf = HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(COLOUR_BINDING),
     		mRenderOp.vertexData->vertexCount,
     		HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
     	bind->setBinding(COLOUR_BINDING, cbuf);
     	size_t charlen = mCaption.size();
     	//Real *pPCBuff = static_cast<Real*>(ptbuf->lock(HardwareBuffer::HBL_NORMAL));
     	Real *pPCBuff=(Real*)ror_malloc(ptbuf->getSizeInBytes());
     	Real *oPCBuff=pPCBuff;
     	float largestWidth = 0;
     	float left = 0 * 2.0 - 1.0;
     	float top = -((0 * 2.0) - 1.0);
     	// Derive space width from a capital A
     	if (fabs(mSpaceWidth) < 0.00001f)
     		mSpaceWidth = mpFont->getGlyphAspectRatio('A') * mCharHeight * 2.0;
     	// for calculation of AABB
     	Ogre::Vector3 min=Ogre::Vector3::ZERO, max=Ogre::Vector3::ZERO, currPos=Ogre::Vector3::ZERO;
     	Ogre::Real maxSquaredRadius = 0.0f;
     	bool first = true;
     	// Use iterator
     	String::iterator i, iend;
     	iend = mCaption.end();
     	bool newLine = true;
     	Real len = 0.0f;
     	if(mVerticalAlignment == MovableText::V_ABOVE)
+    	{
     		// Raise the first line of the caption
     		top += mCharHeight;
     		for (i = mCaption.begin(); i != iend; ++i)
+    		{
     			if (*i == '\n')
     				top += mCharHeight * 2.0;
+    		}
+    	}
     	for (i = mCaption.begin(); i != iend; ++i)
+    	{
     		if (newLine)
+    		{
     			len = 0.0f;
     			for (String::iterator j = i; j != iend && *j != '\n'; j++)
+    			{
     				if (*j == ' ')
     					len += mSpaceWidth;
     				else
     					len += mpFont->getGlyphAspectRatio(*j) * mCharHeight * 2.0;
+    			}
     			newLine = false;
+    		}
     		if (*i == '\n')
+    		{
     			left = 0 * 2.0 - 1.0;
     			top -= mCharHeight * 2.0;
     			newLine = true;
     			continue;
+    		}
     		if (*i == ' ')
+    		{
     			// Just leave a gap, no tris
     			left += mSpaceWidth;
     			// Also reduce tri count
     			mRenderOp.vertexData->vertexCount -= 6;
     			continue;
+    		}
     		Real horiz_height = mpFont->getGlyphAspectRatio(*i);
     		Real u1, u2, v1, v2;
     		Ogre::Font::UVRect utmp;
     		utmp = mpFont->getGlyphTexCoords(*i);
     		u1 = utmp.left;
     		u2 = utmp.right;
     		v1 = utmp.top;
     		v2 = utmp.bottom;
     		// each vert is (x, y, z, u, v)
     		//-------------------------------------------------------------------------------------
     		// First tri
     		//
     		// Upper left
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			*pPCBuff++ = left;
     		else
     			*pPCBuff++ = left - (len / 2);
     		*pPCBuff++ = top;
     		*pPCBuff++ = -1.0;
     		*pPCBuff++ = u1;
     		*pPCBuff++ = v1;
     		// Deal with bounds
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			currPos = Ogre::Vector3(left, top, -1.0);
     		else
     			currPos = Ogre::Vector3(left - (len / 2), top, -1.0);
     		if (first)
+    		{
     			min = max = currPos;
     			maxSquaredRadius = currPos.squaredLength();
     			first = false;
+    		}
     		else
+    		{
     			min.makeFloor(currPos);
     			max.makeCeil(currPos);
     			maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
+    		}
     		top -= mCharHeight * 2.0;
     		// Bottom left
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			*pPCBuff++ = left;
     		else
     			*pPCBuff++ = left - (len / 2);
     		*pPCBuff++ = top;
     		*pPCBuff++ = -1.0;
     		*pPCBuff++ = u1;
     		*pPCBuff++ = v2;
     		// Deal with bounds
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			currPos = Ogre::Vector3(left, top, -1.0);
     		else
     			currPos = Ogre::Vector3(left - (len / 2), top, -1.0);
     		min.makeFloor(currPos);
     		max.makeCeil(currPos);
     		maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
     		top += mCharHeight * 2.0;
     		left += horiz_height * mCharHeight * 2.0;
     		// Top right
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			*pPCBuff++ = left;
     		else
     			*pPCBuff++ = left - (len / 2);
     		*pPCBuff++ = top;
     		*pPCBuff++ = -1.0;
     		*pPCBuff++ = u2;
     		*pPCBuff++ = v1;
     		//-------------------------------------------------------------------------------------
     		// Deal with bounds
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			currPos = Ogre::Vector3(left, top, -1.0);
     		else
     			currPos = Ogre::Vector3(left - (len / 2), top, -1.0);
     		min.makeFloor(currPos);
     		max.makeCeil(currPos);
     		maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
     		//-------------------------------------------------------------------------------------
     		// Second tri
     		//
     		// Top right (again)
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			*pPCBuff++ = left;
     		else
     			*pPCBuff++ = left - (len / 2);
     		*pPCBuff++ = top;
     		*pPCBuff++ = -1.0;
     		*pPCBuff++ = u2;
     		*pPCBuff++ = v1;
     		currPos = Ogre::Vector3(left, top, -1.0);
     		min.makeFloor(currPos);
     		max.makeCeil(currPos);
     		maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
     		top -= mCharHeight * 2.0;
     		left -= horiz_height  * mCharHeight * 2.0;
     		// Bottom left (again)
     		if(mHorizontalAlignment == MovableText::H_LEFT)
     			*pPCBuff++ = left;
     		else
     			*pPCBuff++ = left - (len / 2);
     		*pPCBuff++ = top;
     		*pPCBuff++ = -1.0;
     		*pPCBuff++ = u1;
     		*pPCBuff++ = v2;
     		currPos = Ogre::Vector3(left, top, -1.0);
     		min.makeFloor(currPos);
     		max.makeCeil(currPos);
     		maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
     		left += horiz_height  * mCharHeight * 2.0;
     		// Bottom right
     		if(mHorizontalAlignment == MovableText::H_LEFT)