- rollback last commit

source/g3d_viewer/main.cpp

@@ -1340,12 +1340,11 @@ void MainWindow::loadParticle(string path) {
                 (*it)->setValues(ups);
                 if(size > 0) {
                     //getCurrVectorFlat() + Vec3f(0.f, type->getHeight()/2.f, 0.f);
-                    Vec3d vec = Vec3d(0.f, height / 2.f, 0.f);
+                    Vec3f vec = Vec3f(0.f, height / 2.f, 0.f);
                     ups->setPos(vec);
                 }
                 //ups->setFactionColor(getFaction()->getTexture()->getPixmap()->getPixel3f(0,0));
-                Vec3d factionColor(renderer->getPlayerColorTexture(playerColor)->getPixmap()->getPixel3f(0,0));
-                ups->setFactionColor(factionColor);
+                ups->setFactionColor(renderer->getPlayerColorTexture(playerColor)->getPixmap()->getPixel3f(0,0));
                 unitParticleSystems.push_back(ups);
                 renderer->manageParticleSystem(ups);
 
@@ -1458,9 +1457,9 @@ void MainWindow::loadProjectileParticle(string path) {
 					//ps->setPos(vec);
 
 					Vec3f vec2 = Vec3f(size * 2.f, height * 2.f, height * 2.f);
-					ps->setPath(Vec3d(vec), Vec3d(vec2));
+					ps->setPath(vec, vec2);
 				}
-				ps->setFactionColor(Vec3d(renderer->getPlayerColorTexture(playerColor)->getPixmap()->getPixel3f(0,0)));
+				ps->setFactionColor(renderer->getPlayerColorTexture(playerColor)->getPixmap()->getPixel3f(0,0));
 
 				projectileParticleSystems.push_back(ps);
 
@@ -1569,7 +1568,7 @@ void MainWindow::loadSplashParticle(string path) {  // uses ParticleSystemTypeSp
 					//Vec3f vec2 = Vec3f(size * 2.f, height * 2.f, height * 2.f);   // <------- removed relative projectile
 					//ps->setPath(vec, vec2);                                       // <------- removed relative projectile
 				}
-				ps->setFactionColor(Vec3d(renderer->getPlayerColorTexture(playerColor)->getPixmap()->getPixel3f(0,0)));
+				ps->setFactionColor(renderer->getPlayerColorTexture(playerColor)->getPixmap()->getPixel3f(0,0));
 
 				splashParticleSystems.push_back(ps);
 

source/glest_game/game/game.cpp

@@ -1416,14 +1416,14 @@ void Game::init(bool initForPreviewOnly) {
 				logger.add(Lang::getInstance().get("LogScreenGameLoadingCreatingRainParticles","",true), true);
 				weatherParticleSystem= new RainParticleSystem();
 				weatherParticleSystem->setSpeed(12.f / GameConstants::updateFps);
-				weatherParticleSystem->setPos(Vec3d(gameCamera.getPos()));
+				weatherParticleSystem->setPos(gameCamera.getPos());
 				renderer.manageParticleSystem(weatherParticleSystem, rsGame);
 			}
 			else if(world.getTileset()->getWeather() == wSnowy) {
 				logger.add(Lang::getInstance().get("LogScreenGameLoadingCreatingSnowParticles","",true), true);
 				weatherParticleSystem= new SnowParticleSystem(1200);
 				weatherParticleSystem->setSpeed(1.5f / GameConstants::updateFps);
-				weatherParticleSystem->setPos(Vec3d(gameCamera.getPos()));
+				weatherParticleSystem->setPos(gameCamera.getPos());
 				weatherParticleSystem->setTexture(coreData.getSnowTexture());
 				renderer.manageParticleSystem(weatherParticleSystem, rsGame);
 			}
@@ -2141,9 +2141,9 @@ void Game::update() {
 					}
 
 					if(currentCameraFollowUnit!=NULL){
-						Vec3d c=currentCameraFollowUnit->getCurrVector();
+						Vec3f c=currentCameraFollowUnit->getCurrVector();
 						int rotation=currentCameraFollowUnit->getRotation();
-						double angle=rotation+180;
+						float angle=rotation+180;
 
 
 //#ifdef USE_STREFLOP
@@ -2158,7 +2158,7 @@ void Game::update() {
 
 						c.y=c.y+currentCameraFollowUnit->getType()->getHeight()/2.f+2.0f;
 
-						getGameCameraPtr()->setPos(Vec3f(c));
+						getGameCameraPtr()->setPos(c);
 
 						rotation=(540-rotation)%360;
 						getGameCameraPtr()->rotateToVH(18.0f,rotation);
@@ -2198,7 +2198,7 @@ void Game::update() {
 
 					//Particle systems
 					if(weatherParticleSystem != NULL) {
-						weatherParticleSystem->setPos(Vec3d(gameCamera.getPos()));
+						weatherParticleSystem->setPos(gameCamera.getPos());
 					}
 
 					if(SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled && chrono.getMillis() > 0) SystemFlags::OutputDebug(SystemFlags::debugPerformance,"In [%s::%s] Line: %d took msecs: %lld [weather particle updating i = %d]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,chrono.getMillis(),i);
@@ -4448,7 +4448,7 @@ void Game::startCameraFollowUnit() {
 		if(currentUnit != NULL) {
 			currentCameraFollowUnit = currentUnit;
 			getGameCameraPtr()->setState(GameCamera::sUnit);
-			getGameCameraPtr()->setPos(Vec3f(currentCameraFollowUnit->getCurrVector()));
+			getGameCameraPtr()->setPos(currentCameraFollowUnit->getCurrVector());
 
 			int rotation=currentCameraFollowUnit->getRotation();
 			getGameCameraPtr()->stop();

source/glest_game/graphics/particle_type.cpp

@@ -327,7 +327,7 @@ void ParticleSystemType::saveGame(XmlNode *rootNode) {
 //	Texture2D *texture;
 //	Model *model;
 //	float modelCycle;
-	particleSystemTypeNode->addAttribute("modelCycle",doubleToStr(modelCycle,16), mapTagReplacements);
+	particleSystemTypeNode->addAttribute("modelCycle",floatToStr(modelCycle,16), mapTagReplacements);
 //	string primitive;
 	particleSystemTypeNode->addAttribute("primitive",primitive, mapTagReplacements);
 //	Vec3f offset;
@@ -337,15 +337,15 @@ void ParticleSystemType::saveGame(XmlNode *rootNode) {
 //	Vec4f colorNoEnergy;
 	particleSystemTypeNode->addAttribute("colorNoEnergy",colorNoEnergy.getString(), mapTagReplacements);
 //	float size;
-	particleSystemTypeNode->addAttribute("size",doubleToStr(size,16), mapTagReplacements);
+	particleSystemTypeNode->addAttribute("size",floatToStr(size,16), mapTagReplacements);
 //	float sizeNoEnergy;
-	particleSystemTypeNode->addAttribute("sizeNoEnergy",doubleToStr(sizeNoEnergy,16), mapTagReplacements);
+	particleSystemTypeNode->addAttribute("sizeNoEnergy",floatToStr(sizeNoEnergy,16), mapTagReplacements);
 //	float speed;
-	particleSystemTypeNode->addAttribute("speed",doubleToStr(speed,16), mapTagReplacements);
+	particleSystemTypeNode->addAttribute("speed",floatToStr(speed,16), mapTagReplacements);
 //	float gravity;
-	particleSystemTypeNode->addAttribute("gravity",doubleToStr(gravity,16), mapTagReplacements);
+	particleSystemTypeNode->addAttribute("gravity",floatToStr(gravity,16), mapTagReplacements);
 //	float emissionRate;
-	particleSystemTypeNode->addAttribute("emissionRate",doubleToStr(emissionRate,16), mapTagReplacements);
+	particleSystemTypeNode->addAttribute("emissionRate",floatToStr(emissionRate,16), mapTagReplacements);
 //	int energyMax;
 	particleSystemTypeNode->addAttribute("energyMax",intToStr(energyMax), mapTagReplacements);
 //	int energyVar;
@@ -408,18 +408,18 @@ void ParticleSystemTypeProjectile::load(const XmlNode* particleFileNode, const s
 		ParticleSystemType::load(particleSystemNode, dir, renderer, loadedFileList,parentLoader, techtreePath);
 
 		//trajectory values
-		const XmlNode *trajectoryNode= particleSystemNode->getChild("trajectory");
-		trajectory= trajectoryNode->getAttribute("type")->getRestrictedValue();
+		const XmlNode *tajectoryNode= particleSystemNode->getChild("trajectory");
+		trajectory= tajectoryNode->getAttribute("type")->getRestrictedValue();
 
 		//trajectory speed
-		const XmlNode *trajectorySpeedNode= trajectoryNode->getChild("speed");
-		trajectorySpeed= trajectorySpeedNode->getAttribute("value")->getFloatValue() / (double)GameConstants::updateFps;
+		const XmlNode *tajectorySpeedNode= tajectoryNode->getChild("speed");
+		trajectorySpeed= tajectorySpeedNode->getAttribute("value")->getFloatValue() / (float)GameConstants::updateFps;
 		//printf("[%s] trajectorySpeed = %f\n",path.c_str(),trajectorySpeed);
 
 		if(trajectory=="parabolic" || trajectory=="spiral"){
 			//trajectory scale
-			const XmlNode *trajectoryScaleNode= trajectoryNode->getChild("scale");
-			trajectoryScale= trajectoryScaleNode->getAttribute("value")->getFloatValue();
+			const XmlNode *tajectoryScaleNode= tajectoryNode->getChild("scale");
+			trajectoryScale= tajectoryScaleNode->getAttribute("value")->getFloatValue();
 		}
 		else{
 			trajectoryScale= 1.0f;
@@ -427,8 +427,8 @@ void ParticleSystemTypeProjectile::load(const XmlNode* particleFileNode, const s
 
 		if(trajectory=="spiral"){
 			//trajectory frequency
-			const XmlNode *trajectoryFrequencyNode= trajectoryNode->getChild("frequency");
-			trajectoryFrequency= trajectoryFrequencyNode->getAttribute("value")->getFloatValue();
+			const XmlNode *tajectoryFrequencyNode= tajectoryNode->getChild("frequency");
+			trajectoryFrequency= tajectoryFrequencyNode->getAttribute("value")->getFloatValue();
 		}
 		else{
 			trajectoryFrequency= 1.0f;
@@ -466,11 +466,11 @@ void ParticleSystemTypeProjectile::saveGame(XmlNode *rootNode) {
 //	string trajectory;
 	particleSystemTypeProjectileNode->addAttribute("trajectory",trajectory, mapTagReplacements);
 //	float trajectorySpeed;
-	particleSystemTypeProjectileNode->addAttribute("trajectorySpeed",doubleToStr(trajectorySpeed,16), mapTagReplacements);
+	particleSystemTypeProjectileNode->addAttribute("trajectorySpeed",floatToStr(trajectorySpeed,16), mapTagReplacements);
 //	float trajectoryScale;
-	particleSystemTypeProjectileNode->addAttribute("trajectoryScale",doubleToStr(trajectoryScale,16), mapTagReplacements);
+	particleSystemTypeProjectileNode->addAttribute("trajectoryScale",floatToStr(trajectoryScale,16), mapTagReplacements);
 //	float trajectoryFrequency;
-	particleSystemTypeProjectileNode->addAttribute("trajectoryFrequency",doubleToStr(trajectoryFrequency,16), mapTagReplacements);
+	particleSystemTypeProjectileNode->addAttribute("trajectoryFrequency",floatToStr(trajectoryFrequency,16), mapTagReplacements);
 }
 
 // ===========================================================
@@ -549,15 +549,15 @@ void ParticleSystemTypeSplash::saveGame(XmlNode *rootNode) {
 	XmlNode *particleSystemTypeSplashNode = rootNode->addChild("ParticleSystemTypeSplash");
 
 //	float emissionRateFade;
-	particleSystemTypeSplashNode->addAttribute("emissionRateFade",doubleToStr(emissionRateFade,16), mapTagReplacements);
+	particleSystemTypeSplashNode->addAttribute("emissionRateFade",floatToStr(emissionRateFade,16), mapTagReplacements);
 //	float verticalSpreadA;
-	particleSystemTypeSplashNode->addAttribute("verticalSpreadA",doubleToStr(verticalSpreadA,16), mapTagReplacements);
+	particleSystemTypeSplashNode->addAttribute("verticalSpreadA",floatToStr(verticalSpreadA,16), mapTagReplacements);
 //	float verticalSpreadB;
-	particleSystemTypeSplashNode->addAttribute("verticalSpreadB",doubleToStr(verticalSpreadB,16), mapTagReplacements);
+	particleSystemTypeSplashNode->addAttribute("verticalSpreadB",floatToStr(verticalSpreadB,16), mapTagReplacements);
 //	float horizontalSpreadA;
-	particleSystemTypeSplashNode->addAttribute("horizontalSpreadA",doubleToStr(horizontalSpreadA,16), mapTagReplacements);
+	particleSystemTypeSplashNode->addAttribute("horizontalSpreadA",floatToStr(horizontalSpreadA,16), mapTagReplacements);
 //	float horizontalSpreadB;
-	particleSystemTypeSplashNode->addAttribute("horizontalSpreadB",doubleToStr(horizontalSpreadB,16), mapTagReplacements);
+	particleSystemTypeSplashNode->addAttribute("horizontalSpreadB",floatToStr(horizontalSpreadB,16), mapTagReplacements);
 }
 
 }}//end mamespace

source/glest_game/graphics/particle_type.h

@@ -57,16 +57,16 @@ protected:
 	string type;
 	Texture2D *texture;
 	Model *model;
-	double modelCycle;
+	float modelCycle;
 	string primitive;
-	Vec3d offset;
-	Vec4d color;
-	Vec4d colorNoEnergy;
-	double size;
-	double sizeNoEnergy;
-	double speed;
-	double gravity;
-	double emissionRate;
+	Vec3f offset;
+	Vec4f color;
+	Vec4f colorNoEnergy;
+	float size;
+	float sizeNoEnergy;
+	float speed;
+	float gravity;
+	float emissionRate;
 	int energyMax;
 	int energyVar;
 	string mode;
@@ -123,9 +123,9 @@ protected:
 class ParticleSystemTypeProjectile: public ParticleSystemType{
 private:
 	string trajectory;
-	double trajectorySpeed;
-	double trajectoryScale;
-	double trajectoryFrequency;
+	float trajectorySpeed;
+	float trajectoryScale;
+	float trajectoryFrequency;
 
 public:
 	ParticleSystemTypeProjectile();
@@ -153,11 +153,11 @@ public:
 	virtual void saveGame(XmlNode *rootNode);
 
 private:
-	double emissionRateFade;
-	double verticalSpreadA;
-	double verticalSpreadB;
-	double horizontalSpreadA;
-	double horizontalSpreadB;
+	float emissionRateFade;
+	float verticalSpreadA;
+	float verticalSpreadB;
+	float horizontalSpreadA;
+	float horizontalSpreadB;
 };
 
 }}//end namespace

source/glest_game/graphics/renderer.cpp

@@ -1054,11 +1054,11 @@ void Renderer::setupLighting() {
 				Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
 
 				if(world->toRenderUnit(unit) &&
-					unit->getCurrVector().dist(Vec3d(gameCamera->getPos())) < maxLightDist &&
+					unit->getCurrVector().dist(gameCamera->getPos()) < maxLightDist &&
 					unit->getType()->getLight() && unit->isOperative()) {
 					//printf("$$$ Show light for faction: %s # %d / %d for Unit [%d - %s]\n",world->getFaction(i)->getType()->getName().c_str(),lightCount,maxLights,unit->getId(),unit->getFullName().c_str());
 
-					Vec4f pos= Vec4f(unit->getCurrVector().x,unit->getCurrVector().y,unit->getCurrVector().z,0);
+					Vec4f pos= Vec4f(unit->getCurrVector());
 					pos.y+=4.f;
 
 					GLenum lightEnum= GL_LIGHT0 + lightCount;
@@ -4636,7 +4636,7 @@ void Renderer::renderObjects(const int renderFps) {
 
 		Model *objModel= o->getModelPtr();
 		//objModel->updateInterpolationData(o->getAnimProgress(), true);
-		const Vec3f &v= Vec3f(o->getConstPos());
+		const Vec3f &v= o->getConstPos();
 
 		if(modelRenderStarted == false) {
 			modelRenderStarted = true;
@@ -4878,7 +4878,7 @@ void Renderer::renderTeamColorCircle(){
 		for(int visibleUnitIndex = 0;
 							visibleUnitIndex < qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
 				Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
-				Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+				Vec3f currVec= unit->getCurrVectorFlat();
 				Vec3f color=unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0);
 				glColor4f(color.x, color.y, color.z, 0.7f);
 				renderSelectionCircle(currVec, unit->getType()->getSize(), 0.8f, 0.05f);
@@ -4933,7 +4933,7 @@ void Renderer::renderSpecialHighlightUnits(std::map<int,HighlightSpecialUnitInfo
 
 					glColor4f(color.x, color.y, color.z, alpha);
 
-					Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+					Vec3f currVec= unit->getCurrVectorFlat();
 					renderSelectionCircle(currVec, unit->getType()->getSize(), radius, thickness);
 				}
 		}
@@ -4957,7 +4957,7 @@ void Renderer::renderTeamColorPlane(){
 		for(int visibleUnitIndex = 0;
 				visibleUnitIndex < qCache.visibleQuadUnitList.size(); ++visibleUnitIndex){
 			Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
-			Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+			Vec3f currVec= unit->getCurrVectorFlat();
 			renderTeamColorEffect(currVec,visibleUnitIndex,unit->getType()->getSize(),
 					unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0),texture);
 		}
@@ -5074,7 +5074,7 @@ void Renderer::renderUnits(const int renderFps) {
 			glPushMatrix();
 
 			//translate
-			Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+			Vec3f currVec= unit->getCurrVectorFlat();
 			glTranslatef(currVec.x, currVec.y, currVec.z);
 
 			//rotate
@@ -5245,7 +5245,7 @@ void Renderer::renderMorphEffects(){
 							initialized=true;
 						}
 
-						Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+						Vec3f currVec= unit->getCurrVectorFlat();
 						currVec=Vec3f(currVec.x,currVec.y+0.3f,currVec.z);
 						if(mType->getField() == fAir && unit->getType()->getField()== fLand) {
 							currVec=Vec3f(currVec.x,currVec.y+game->getWorld()->getTileset()->getAirHeight(),currVec.z);
@@ -5299,7 +5299,7 @@ void Renderer::renderSelectionEffects() {
 		const Unit *unit= selection->getUnit(i);
 		if(unit != NULL) {
 			//translate
-			Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+			Vec3f currVec= unit->getCurrVectorFlat();
 			currVec.y+= 0.3f;
 
 			//selection circle
@@ -5335,7 +5335,7 @@ void Renderer::renderSelectionEffects() {
 						if(i == 0) {
 							lastPosValue = curPosValue;
 						}
-						Vec3f currVec2 = Vec3f(unit->getVectorFlat(lastPosValue,curPosValue));
+						Vec3f currVec2 = unit->getVectorFlat(lastPosValue,curPosValue);
 						currVec2.y+= 0.3f;
 						renderSelectionCircle(currVec2, 1, selectionCircleRadius);
 						//renderSelectionCircle(currVec2, unit->getType()->getSize(), selectionCircleRadius);
@@ -5367,7 +5367,7 @@ void Renderer::renderSelectionEffects() {
 						int findUnitId = effect.currentAttackBoostUnits[i];
 						Unit *affectedUnit = game->getWorld()->findUnitById(findUnitId);
 						if(affectedUnit != NULL) {
-							Vec3f currVecBoost = Vec3f(affectedUnit->getCurrVectorFlat());
+							Vec3f currVecBoost = affectedUnit->getCurrVectorFlat();
 							currVecBoost.y += 0.3f;
 
 							renderSelectionCircle(currVecBoost, affectedUnit->getType()->getSize(), 1.f);
@@ -5383,7 +5383,7 @@ void Renderer::renderSelectionEffects() {
 		int defaultValue= r->getType()->getDefResPerPatch();
 		float colorValue=static_cast<float>(r->getAmount())/static_cast<float>(defaultValue);
 		glColor4f(0.1f, 0.1f , colorValue, 0.4f);
-		renderSelectionCircle(Vec3f(selectedResourceObject->getPos()),2, selectionCircleRadius);
+		renderSelectionCircle(selectedResourceObject->getPos(),2, selectionCircleRadius);
 	}
 	//target arrow
 	if(selection->getCount() == 1) {
@@ -5413,7 +5413,7 @@ void Renderer::renderSelectionEffects() {
 					Vec3f arrowTarget;
 					Command *c= unit->getCurrCommand();
 					if(c->getUnit() != NULL) {
-						arrowTarget= Vec3f(c->getUnit()->getCurrVectorFlat());
+						arrowTarget= c->getUnit()->getCurrVectorFlat();
 					}
 					else {
 						Vec2i pos= c->getPos();
@@ -5422,7 +5422,7 @@ void Renderer::renderSelectionEffects() {
 						arrowTarget= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
 					}
 
-					renderArrow(Vec3f(unit->getCurrVectorFlat()), arrowTarget, arrowColor, 0.3f);
+					renderArrow(unit->getCurrVectorFlat(), arrowTarget, arrowColor, 0.3f);
 				}
 			}
 
@@ -5432,7 +5432,7 @@ void Renderer::renderSelectionEffects() {
 				map->clampPos(pos);
 
 				Vec3f arrowTarget= Vec3f(pos.x, map->getCell(pos)->getHeight(), pos.y);
-				renderArrow(Vec3f(unit->getCurrVectorFlat()), arrowTarget, Vec3f(0.f, 0.f, 1.f), 0.3f);
+				renderArrow(unit->getCurrVectorFlat(), arrowTarget, Vec3f(0.f, 0.f, 1.f), 0.3f);
 			}
 		}
 	}
@@ -5450,7 +5450,7 @@ void Renderer::renderSelectionEffects() {
 				glColor4f(1.f, 0.f, 0.f, highlight);
 			}
 
-			Vec3f v= Vec3f(unit->getCurrVectorFlat());
+			Vec3f v= unit->getCurrVectorFlat();
 			v.y+= 0.3f;
 			renderSelectionCircle(v, unit->getType()->getSize(), 0.5f+0.4f*highlight );
 		}
@@ -5481,7 +5481,7 @@ void Renderer::renderSelectionEffects() {
 		if(object->isHighlighted()) {
 			float highlight= object->getHightlight();
 			glColor4f(0.1f, 0.1f , 1.0f, highlight);
-			Vec3f v= Vec3f(object->getPos());
+			Vec3f v= object->getPos();
 			v.y+= 0.3f;
 			renderSelectionCircle(v, 2, 0.4f+0.4f*highlight );
 		}
@@ -6714,7 +6714,7 @@ void Renderer::selectUsingFrustumSelection(Selection::UnitContainer &units,
 				visibleUnitIndex < qCache.visibleQuadUnitList.size(); ++visibleUnitIndex) {
 			Unit *unit = qCache.visibleQuadUnitList[visibleUnitIndex];
 			if(unit != NULL && unit->isAlive()) {
-				Vec3d unitPos = unit->getCurrVector();
+				Vec3f unitPos = unit->getCurrVector();
 				bool insideQuad = CubeInFrustum(quadSelectionCacheItem.frustumData,
 						unitPos.x, unitPos.y, unitPos.z, unit->getType()->getSize());
 				if(insideQuad == true) {
@@ -7486,7 +7486,7 @@ vector<Unit *> Renderer::renderUnitsFast(bool renderingShadows, bool colorPickin
 				glPushMatrix();
 
 				//translate
-				Vec3f currVec= Vec3f(unit->getCurrVectorFlat());
+				Vec3f currVec= unit->getCurrVectorFlat();
 				glTranslatef(currVec.x, currVec.y, currVec.z);
 
 				//rotate
@@ -7589,7 +7589,7 @@ vector<Object *>  Renderer::renderObjectsFast(bool renderingShadows, bool resour
 					//objModel->updateInterpolationData(o->getAnimProgress(), true);
 
 				//}
-				const Vec3f &v= Vec3f(o->getConstPos());
+				const Vec3f &v= o->getConstPos();
 
 				if(colorPickingSelection == false) {
 					glPushName(OBJECT_SELECT_OFFSET+visibleIndex);

source/glest_game/graphics/unit_particle_type.cpp

@@ -172,7 +172,7 @@ void UnitParticleSystemType::load(const XmlNode *particleSystemNode, const strin
 	// delay
 	if(particleSystemNode->hasChild("delay")) {
 		const XmlNode* delayNode = particleSystemNode->getChild("delay");
-		const double delay_secs = delayNode->getAttribute("value")->getFloatValue();
+		const float delay_secs = delayNode->getAttribute("value")->getFloatValue();
 		if(delay_secs < 0)
 			throw megaglest_runtime_error("particle effect delay cannot be negative");
 		delay = (int)delay_secs * GameConstants::updateFps;
@@ -183,7 +183,7 @@ void UnitParticleSystemType::load(const XmlNode *particleSystemNode, const strin
 	// lifetime
 	if(particleSystemNode->hasChild("lifetime")) {
 		const XmlNode* lifetimeNode = particleSystemNode->getChild("lifetime");
-		const double lifetime_secs = lifetimeNode->getAttribute("value")->getFloatValue();
+		const float lifetime_secs = lifetimeNode->getAttribute("value")->getFloatValue();
 		if(lifetime_secs < 0 && lifetime_secs != -1)
 			throw megaglest_runtime_error("particle effect lifetime cannot be negative (-1 means inherited from parent particle)");
 		lifetime = (int)lifetime_secs * GameConstants::updateFps;
@@ -300,13 +300,13 @@ void UnitParticleSystemType::saveGame(XmlNode *rootNode) {
 //	UnitParticleSystem::Shape shape;
 	unitParticleSystemTypeNode->addAttribute("shape",intToStr(shape), mapTagReplacements);
 //	float angle;
-	unitParticleSystemTypeNode->addAttribute("angle",doubleToStr(angle,16), mapTagReplacements);
+	unitParticleSystemTypeNode->addAttribute("angle",floatToStr(angle,16), mapTagReplacements);
 //	float radius;
-	unitParticleSystemTypeNode->addAttribute("radius",doubleToStr(radius,16), mapTagReplacements);
+	unitParticleSystemTypeNode->addAttribute("radius",floatToStr(radius,16), mapTagReplacements);
 //	float minRadius;
-	unitParticleSystemTypeNode->addAttribute("minRadius",doubleToStr(minRadius,16), mapTagReplacements);
+	unitParticleSystemTypeNode->addAttribute("minRadius",floatToStr(minRadius,16), mapTagReplacements);
 //	float emissionRateFade;
-	unitParticleSystemTypeNode->addAttribute("emissionRateFade",doubleToStr(emissionRateFade,16), mapTagReplacements);
+	unitParticleSystemTypeNode->addAttribute("emissionRateFade",floatToStr(emissionRateFade,16), mapTagReplacements);
 //	Vec3f direction;
 	unitParticleSystemTypeNode->addAttribute("direction",direction.getString(), mapTagReplacements);
 //    bool relative;
@@ -330,9 +330,9 @@ void UnitParticleSystemType::saveGame(XmlNode *rootNode) {
 //	int lifetime;
 	unitParticleSystemTypeNode->addAttribute("lifetime",intToStr(lifetime), mapTagReplacements);
 //	float startTime;
-	unitParticleSystemTypeNode->addAttribute("startTime",doubleToStr(startTime,16), mapTagReplacements);
+	unitParticleSystemTypeNode->addAttribute("startTime",floatToStr(startTime,16), mapTagReplacements);
 //	float endTime;
-	unitParticleSystemTypeNode->addAttribute("endTime",doubleToStr(endTime,16), mapTagReplacements);
+	unitParticleSystemTypeNode->addAttribute("endTime",floatToStr(endTime,16), mapTagReplacements);
 }
 
 }}//end mamespace

source/glest_game/graphics/unit_particle_type.h

@@ -52,11 +52,11 @@ using Shared::Xml::XmlNode;
 class UnitParticleSystemType: public ParticleSystemType {
 protected:
 	UnitParticleSystem::Shape shape;
-	double angle;
-	double radius;
-	double minRadius;
-	double emissionRateFade;
-	Vec3d direction;
+	float angle;
+	float radius;
+	float minRadius;
+	float emissionRateFade;
+	Vec3f direction;
     bool relative;
     bool relativeDirection;
     bool fixed;
@@ -67,8 +67,8 @@ protected:
 	bool radiusBasedStartenergy;
 	int delay;
 	int lifetime;
-	double startTime;
-	double endTime;
+	float startTime;
+	float endTime;
 
 public:
 	UnitParticleSystemType();
@@ -81,10 +81,10 @@ public:
 			std::map<string,vector<pair<string, string> > > &loadedFileList,string parentLoader,
 			string techtreePath);
 
-	void setStartTime(double startTime) { this->startTime = startTime; }
-	double getStartTime() const { return this->startTime; }
-	void setEndTime(double endTime) { this->endTime = endTime; }
-	double getEndTime() const { return this->endTime; }
+	void setStartTime(float startTime) { this->startTime = startTime; }
+	float getStartTime() const { return this->startTime; }
+	void setEndTime(float endTime) { this->endTime = endTime; }
+	float getEndTime() const { return this->endTime; }
 
 	const void setValues (UnitParticleSystem *uts);
 	bool hasTexture() const { return(texture != NULL); }

source/glest_game/gui/gui.cpp

@@ -305,7 +305,7 @@ void Gui::mouseUpLeftGraphics(int x, int y) {
 			if(selection.isCommandable() && random.randRange(0, 1)==0){
 				SoundRenderer::getInstance().playFx(
 					selection.getFrontUnit()->getType()->getSelectionSound(),
-					Vec3f(selection.getFrontUnit()->getCurrVector()),
+					selection.getFrontUnit()->getCurrVector(),
 					gameCamera->getPos());
 			}
 			selectionQuad.disable();
@@ -477,7 +477,7 @@ void Gui::giveDefaultOrders(int x, int y,const Unit *targetUnit, bool paintMouse
 		if(random.randRange(0, 1)==0){
 			SoundRenderer::getInstance().playFx(
 				selection.getFrontUnit()->getType()->getCommandSound(),
-				Vec3f(selection.getFrontUnit()->getCurrVector()),
+				selection.getFrontUnit()->getCurrVector(),
 				gameCamera->getPos());
 		}
 	}
@@ -532,7 +532,7 @@ void Gui::giveTwoClickOrders(int x, int y , bool prepared) {
 		if(random.randRange(0, 1) == 0) {
 			SoundRenderer::getInstance().playFx(
 				selection.getFrontUnit()->getType()->getCommandSound(),
-				Vec3f(selection.getFrontUnit()->getCurrVector()),
+				selection.getFrontUnit()->getCurrVector(),
 				gameCamera->getPos());
 		}
 	}
@@ -540,7 +540,7 @@ void Gui::giveTwoClickOrders(int x, int y , bool prepared) {
 
 void Gui::centerCameraOnSelection() {
 	if(selection.isEmpty() == false) {
-		Vec3f refPos= Vec3f(selection.getRefPos());
+		Vec3f refPos= selection.getRefPos();
 		gameCamera->centerXZ(refPos.x, refPos.z);
 	}
 }

source/glest_game/gui/selection.cpp

@@ -186,7 +186,7 @@ bool Selection::isMeetable() const{
 		selectedUnits.front()->getType()->getMeetingPoint();
 }
 
-Vec3d Selection::getRefPos() const{
+Vec3f Selection::getRefPos() const{
 	return getFrontUnit()->getCurrVector();
 }
 

source/glest_game/gui/selection.h

@@ -85,7 +85,7 @@ public:
 	const Unit *getUnit(int i) const	{return selectedUnits[i];}
 	Unit *getUnitPtr(int i) 			{return selectedUnits[i];}
 	const Unit *getFrontUnit() const	{return selectedUnits.front();}
-	Vec3d getRefPos() const;
+	Vec3f getRefPos() const;
 	bool hasUnit(const Unit* unit) const;
 	
 	void assignGroup(int groupIndex,const UnitContainer *pUnits=NULL);

source/glest_game/menu/menu_background.cpp

@@ -160,8 +160,8 @@ void MenuBackground::createRainParticleSystem() {
 		rps->setSpeed(12.f/GameConstants::updateFps);
 		rps->setEmissionRate(25);
 		rps->setWind(-90.f, 4.f/GameConstants::updateFps);
-		rps->setPos(Vec3d(0.f, 25.f, 0.f));
-		rps->setColor(Vec4d(1.f, 1.f, 1.f, 0.2f));
+		rps->setPos(Vec3f(0.f, 25.f, 0.f));
+		rps->setColor(Vec4f(1.f, 1.f, 1.f, 0.2f));
 		rps->setRadius(30.f);
 
 		Renderer &renderer= Renderer::getInstance();

source/glest_game/type_instances/object.cpp

@@ -34,7 +34,7 @@ ObjectStateInterface *Object::stateCallback=NULL;
 // 	class Object
 // =====================================================
 
-Object::Object(ObjectType *objectType, const Vec3d &pos, const Vec2i &mapPos) : BaseColorPickEntity() {
+Object::Object(ObjectType *objectType, const Vec3f &pos, const Vec2i &mapPos) : BaseColorPickEntity() {
 	RandomGen random;
 
 	random.init(static_cast<int>(pos.x*pos.z));
@@ -44,7 +44,7 @@ Object::Object(ObjectType *objectType, const Vec3d &pos, const Vec2i &mapPos) :
 	highlight= 0.f;
 	animated= false;
 	this->mapPos = mapPos;
-	this->pos= pos + Vec3d(random.randRange(-0.6f, 0.6f), 0.0f, random.randRange(-0.6f, 0.6f));
+	this->pos= pos + Vec3f(random.randRange(-0.6f, 0.6f), 0.0f, random.randRange(-0.6f, 0.6f));
 	rotation= random.randRange(0.f, 360.f);
 	if(objectType!=NULL){
 		variation = random.randRange(0, objectType->getModelCount()-1);
@@ -111,7 +111,7 @@ void Object::initParticlesFromTypes(const ModelParticleSystemTypes *particleType
 			(*it)->setValues(ups);
 			ups->setPos(this->pos);
 			ups->setRotation(this->rotation);
-			ups->setFactionColor(Vec3d(0, 0, 0));
+			ups->setFactionColor(Vec3f(0, 0, 0));
 			ups->setVisible(false);
 			this->unitParticleSystems.push_back(ups);
 			Renderer::getInstance().manageParticleSystem(ups, rsGame);
@@ -126,7 +126,7 @@ void Object::end(ParticleSystem *particleSystem) {
 	}
 }
 
-void Object::setHeight(double height) {
+void Object::setHeight(float height) {
 	pos.y=height;
 
 	for(UnitParticleSystems::iterator it= unitParticleSystems.begin(); it != unitParticleSystems.end(); ++it) {
@@ -153,17 +153,17 @@ void Object::update() {
 //		printf("#1 Object updating [%s] Speed [%d] animProgress [%f]\n",this->objectType->getTilesetModelType(variation)->getModel()->getFileName().c_str(),objectType->getTilesetModelType(variation)->getAnimSpeed(),animProgress);
 
 		if(objectType != NULL && objectType->getTilesetModelType(variation) != NULL) {
-			double heightFactor   = 1.f;
-			const double speedDivider= 100.f;
-			double speedDenominator = (speedDivider * GameConstants::updateFps);
+			float heightFactor   = 1.f;
+			const float speedDivider= 100.f;
+			float speedDenominator = (speedDivider * GameConstants::updateFps);
 
 			// smooth TwoFrameanimations
-			double f=1.0f;
+			float f=1.0f;
 			if(objectType->getTilesetModelType(variation)->getSmoothTwoFrameAnim()==true){
 				f=abs(std::sin(animProgress*2*3.16))+0.4f;
 			}
 
-			double newAnimProgress = animProgress + f*(((double)objectType->getTilesetModelType(variation)->getAnimSpeed() * heightFactor) / speedDenominator);
+			float newAnimProgress = animProgress + f*(((float)objectType->getTilesetModelType(variation)->getAnimSpeed() * heightFactor) / speedDenominator);
 
 	//		printf("A [%f] B [%f] C [%f] D [%f] E [%f] F [%f]\n",
 	//				((float)objectType->getTilesetModelType(variation)->getAnimSpeed() * heightFactor),
@@ -265,7 +265,7 @@ void Object::saveGame(XmlNode *rootNode) {
 //	Vec3f pos;
 	objectNode->addAttribute("pos",pos.getString(), mapTagReplacements);
 //	float rotation;
-	objectNode->addAttribute("rotation",doubleToStr(rotation,16), mapTagReplacements);
+	objectNode->addAttribute("rotation",floatToStr(rotation,16), mapTagReplacements);
 //	int variation;
 	objectNode->addAttribute("variation",intToStr(variation), mapTagReplacements);
 //	int lastRenderFrame;
@@ -297,7 +297,7 @@ void Object::loadGame(const XmlNode *rootNode,const TechTree *techTree) {
 		resource->loadGame(objectNode,0,techTree);
 	}
 	//	Vec3f pos;
-	pos = Vec3d::strToVec3(objectNode->getAttribute("pos")->getValue());
+	pos = Vec3f::strToVec3(objectNode->getAttribute("pos")->getValue());
 	//	float rotation;
 	rotation = objectNode->getAttribute("rotation")->getFloatValue();
 	//	int variation;

source/glest_game/type_instances/object.h

@@ -57,20 +57,20 @@ private:
 	ObjectType *objectType;
 	vector<UnitParticleSystem*> unitParticleSystems;
 	Resource *resource;
-	Vec3d pos;
-	double rotation;
+	Vec3f pos;
+	float rotation;
 	int variation;
 	int lastRenderFrame;
 	Vec2i mapPos;
 	bool visible;
 	bool animated;
-	double animProgress;
-	double highlight;
+	float animProgress;
+	float highlight;
 
 	static ObjectStateInterface *stateCallback;
 
 public:
-	Object(ObjectType *objectType, const Vec3d &pos, const Vec2i &mapPos);
+	Object(ObjectType *objectType, const Vec3f &pos, const Vec2i &mapPos);
 	virtual ~Object();
 
 	void end(); //to kill particles
@@ -80,21 +80,21 @@ public:
 
 	const ObjectType *getType() const	{return objectType;}
 	Resource *getResource() const		{return resource;}
-	Vec3d getPos() const				{return pos;}
+	Vec3f getPos() const				{return pos;}
 	bool isVisible() const				{return visible;}
-	const Vec3d & getConstPos() const	{return pos;}
-	double getRotation() const			{return rotation;}
+	const Vec3f & getConstPos() const	{return pos;}
+	float getRotation() const			{return rotation;}
 	const Model *getModel() const;
 	Model *getModelPtr() const;
 	bool getWalkable() const;
 	bool isAnimated() const				{return animated;}
 
-	double getHightlight() const			{return highlight;}
+	float getHightlight() const			{return highlight;}
 	bool isHighlighted() const			{return highlight>0.f;}
 	void resetHighlight();
 
 	void setResource(const ResourceType *resourceType, const Vec2i &pos);
-	void setHeight(double height);
+	void setHeight(float height);
 	void setVisible(bool visible);
 
 	int getLastRenderFrame() const { return lastRenderFrame; }
@@ -104,7 +104,7 @@ public:
 
 	void updateHighlight();
 	void update();
-	double getAnimProgress() const { return animProgress;}
+	float getAnimProgress() const { return animProgress;}
 
 	virtual string getUniquePickName() const;
 	void saveGame(XmlNode *rootNode);

source/glest_game/type_instances/unit.cpp

@@ -453,7 +453,7 @@ Unit::Unit(int id, UnitPathInterface *unitpath, const Vec2i &pos,
 	this->map= map;
 	this->targetRef = NULL;
 	this->targetField = fLand;
-	this->targetVec   = Vec3d(0.0);
+	this->targetVec   = Vec3f(0.0);
 	this->targetPos   = Vec2i(0);
 	this->lastRenderFrame = 0;
 	this->visible = true;
@@ -700,7 +700,7 @@ Vec2i Unit::getCenteredPos() const {
     return pos + Vec2i(type->getSize()/2, type->getSize()/2);
 }
 
-Vec2d Unit::getFloatCenteredPos() const {
+Vec2f Unit::getFloatCenteredPos() const {
 	static string mutexOwnerId = string(__FILE__) + string("_") + intToStr(__LINE__);
 	MutexSafeWrapper safeMutex(mutexCommands,mutexOwnerId);
 
@@ -710,7 +710,7 @@ Vec2d Unit::getFloatCenteredPos() const {
 		throw megaglest_runtime_error(szBuf);
 	}
 
-	return Vec2d(pos.x-0.5f+type->getSize()/2.f, pos.y-0.5f+type->getSize()/2.f);
+	return Vec2f(pos.x-0.5f+type->getSize()/2.f, pos.y-0.5f+type->getSize()/2.f);
 }
 
 Vec2i Unit::getCellPos() const {
@@ -754,7 +754,7 @@ void Unit::calculateXZRotation(){
 	//if(currSkill->getClass()==scMove)
 	if(lastPos != pos){ // targetPosCalc ( maybe also sometimes needed if no move ? terrain flatting... )
 		SurfaceCell* sc= map->getSurfaceCell(Map::toSurfCoords(pos));
-		const Vec3d normal= Vec3d(sc->getNormal());
+		const Vec3f normal= sc->getNormal();
 
 #ifdef USE_STREFLOP
 		targetRotationZ= radToDeg(streflop::atan2(static_cast<streflop::Simple>(abs(normal.x)), static_cast<streflop::Simple>(abs(normal.y))));
@@ -1124,7 +1124,7 @@ void Unit::setCurrSkill(const SkillType *currSkill) {
 				(*it)->setValues(ups);
 				ups->setPos(getCurrVector());
 				if(getFaction()->getTexture()) {
-					ups->setFactionColor(Vec3d(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+					ups->setFactionColor(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 				}
 				unitParticleSystems.push_back(ups);
 				Renderer::getInstance().manageParticleSystem(ups, rsGame);
@@ -1267,7 +1267,7 @@ void Unit::setTargetPos(const Vec2i &targetPos) {
 	Vec2i relPos= targetPos - pos;
 	//map->clampPos(relPos);
 
-	Vec2d relPosf= Vec2d((double)relPos.x, (double)relPos.y);
+	Vec2f relPosf= Vec2f((float)relPos.x, (float)relPos.y);
 #ifdef USE_STREFLOP
 	targetRotation= radToDeg(streflop::atan2(static_cast<streflop::Simple>(relPosf.x), static_cast<streflop::Simple>(relPosf.y)));
 #else
@@ -1411,17 +1411,17 @@ bool Unit::checkModelStateInfoForNewHpValue() {
 	return result;
 }
 
-Vec3d Unit::getCurrVector() const{
+Vec3f Unit::getCurrVector() const{
 	if(type == NULL) {
 		char szBuf[8096]="";
 		snprintf(szBuf,8096,"In [%s::%s Line: %d] ERROR: type == NULL, Unit = [%s]\n",extractFileFromDirectoryPath(__FILE__).c_str(),__FUNCTION__,__LINE__,this->toString().c_str());
 		throw megaglest_runtime_error(szBuf);
 	}
 
-	return getCurrVectorFlat() + Vec3d(0.f, truncateDecimal<double>(type->getHeight()/2.f), 0.f);
+	return getCurrVectorFlat() + Vec3f(0.f, truncateDecimal<float>(type->getHeight()/2.f), 0.f);
 }
 
-Vec3d Unit::getCurrVectorFlat() const{
+Vec3f Unit::getCurrVectorFlat() const{
 	return getVectorFlat(lastPos, pos);
 }
 
@@ -1431,8 +1431,8 @@ double Unit::getProgressAsFloat() const {
 	return result;
 }
 
-Vec3d Unit::getVectorFlat(const Vec2i &lastPosValue, const Vec2i &curPosValue) const {
-    Vec3d v;
+Vec3f Unit::getVectorFlat(const Vec2i &lastPosValue, const Vec2i &curPosValue) const {
+    Vec3f v;
 
     double y1= computeHeight(lastPosValue);
     double y2= computeHeight(curPosValue);
@@ -2145,9 +2145,9 @@ void Unit::updateAttackBoostProgress(const Game* game) {
 						if (getFaction()->getTexture()) {
 							currentAttackBoostOriginatorEffect.
 									currentAppliedEffect->ups->setFactionColor(
-											Vec3d(getFaction()->getTexture()->
+											getFaction()->getTexture()->
 												getPixmapConst()->getPixel3f(
-															0, 0)));
+															0, 0));
 						}
 						Renderer::getInstance().manageParticleSystem(
 								currentAttackBoostOriginatorEffect.currentAppliedEffect->ups,
@@ -2252,8 +2252,8 @@ void Unit::updateAttackBoostProgress(const Game* game) {
 								getCurrVector());
 						if (getFaction()->getTexture()) {
 							currentAttackBoostOriginatorEffect.currentAppliedEffect->ups->setFactionColor(
-									Vec3d(getFaction()->getTexture()->getPixmapConst()->getPixel3f(
-											0, 0)));
+									getFaction()->getTexture()->getPixmapConst()->getPixel3f(
+											0, 0));
 						}
 						Renderer::getInstance().manageParticleSystem(
 								currentAttackBoostOriginatorEffect.currentAppliedEffect->ups,
@@ -2503,7 +2503,7 @@ void Unit::updateTimedParticles() {
 					pst->setValues(ups);
 					ups->setPos(getCurrVector());
 					if(getFaction()->getTexture()) {
-						ups->setFactionColor(Vec3d(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+						ups->setFactionColor(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 					}
 					unitParticleSystems.push_back(ups);
 					Renderer::getInstance().manageParticleSystem(ups, rsGame);
@@ -2640,7 +2640,7 @@ bool Unit::applyAttackBoost(const AttackBoost *boost, const Unit *source) {
 				effect->upst->setValues(effect->ups);
 				effect->ups->setPos(getCurrVector());
 				if(getFaction()->getTexture()) {
-					effect->ups->setFactionColor(Vec3d(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+					effect->ups->setFactionColor(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 				}
 				Renderer::getInstance().manageParticleSystem(effect->ups, rsGame);
 			}
@@ -3376,7 +3376,7 @@ void Unit::updateTarget(){
 		//update target pos
 		targetPos= target->getCellPos();
 		Vec2i relPos= targetPos - pos;
-		Vec2d relPosf= Vec2d((double)relPos.x, (double)relPos.y);
+		Vec2f relPosf= Vec2f((float)relPos.x, (float)relPos.y);
 #ifdef USE_STREFLOP
 		targetRotation= radToDeg(streflop::atan2(static_cast<streflop::Simple>(relPosf.x), static_cast<streflop::Simple>(relPosf.y)));
 #else
@@ -3767,7 +3767,7 @@ void Unit::checkCustomizedParticleTriggers(bool force) {
 					pst->setValues(ups);
 					ups->setPos(getCurrVector());
 					if(getFaction()->getTexture()) {
-						ups->setFactionColor(Vec3d(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+						ups->setFactionColor(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 					}
 					damageParticleSystems.push_back(ups);
 					damageParticleSystemsInUse[i] = ups;
@@ -3792,7 +3792,7 @@ void Unit::startDamageParticles() {
 					pst->setValues(ups);
 					ups->setPos(getCurrVector());
 					if(getFaction()->getTexture()) {
-						ups->setFactionColor(Vec3d(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+						ups->setFactionColor(getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 					}
 					damageParticleSystems.push_back(ups);
 					damageParticleSystemsInUse[i] = ups;
@@ -3819,12 +3819,12 @@ void Unit::startDamageParticles() {
 				// smoke
 				UnitParticleSystem *ups= new UnitParticleSystem(400);
 				ups->setParticleOwner(this);
-				ups->setColorNoEnergy(Vec4d(0.0f, 0.0f, 0.0f, 0.13f));
-				ups->setColor(Vec4d(0.115f, 0.115f, 0.115f, 0.22f));
+				ups->setColorNoEnergy(Vec4f(0.0f, 0.0f, 0.0f, 0.13f));
+				ups->setColor(Vec4f(0.115f, 0.115f, 0.115f, 0.22f));
 				ups->setPos(getCurrVector());
 				ups->setBlendMode(ups->strToBlendMode("black"));
-				ups->setOffset(Vec3d(0,2,0));
-				ups->setDirection(Vec3d(0,1,-0.2f));
+				ups->setOffset(Vec3f(0,2,0));
+				ups->setDirection(Vec3f(0,1,-0.2f));
 				ups->setRadius(type->getSize()/3.f);
 				ups->setShape(Shared::Graphics::UnitParticleSystem::sLinear);
 				ups->setTexture(CoreData::getInstance().getFireTexture());
@@ -3845,7 +3845,7 @@ void Unit::startDamageParticles() {
 	checkCustomizedParticleTriggers(false);
 }
 
-void Unit::setTargetVec(const Vec3d &targetVec)	{
+void Unit::setTargetVec(const Vec3f &targetVec)	{
 	this->targetVec= targetVec;
 	logSynchData(extractFileFromDirectoryPath(__FILE__).c_str(),__LINE__);
 }
@@ -4687,7 +4687,7 @@ Unit * Unit::loadGame(const XmlNode *rootNode, GameSettings *settings, Faction *
 //    Vec2i targetPos;		//absolute target pos
 	result->targetPos = Vec2i::strToVec2(unitNode->getAttribute("targetPos")->getValue());
 //	Vec3f targetVec;
-	result->targetVec = Vec3d::strToVec3(unitNode->getAttribute("targetVec")->getValue());
+	result->targetVec = Vec3f::strToVec3(unitNode->getAttribute("targetVec")->getValue());
 //	Vec2i meetingPos;
 	result->meetingPos = Vec2i::strToVec2(unitNode->getAttribute("meetingPos")->getValue());
 //
@@ -4905,7 +4905,28 @@ Unit * Unit::loadGame(const XmlNode *rootNode, GameSettings *settings, Faction *
 			//ups->setTexture(CoreData::getInstance().getFireTexture());
 			result->smokeParticleSystems.push_back(ups);
 
+//			UnitParticleSystem *ups= new UnitParticleSystem(400);
+//			ups->setColorNoEnergy(Vec4f(0.0f, 0.0f, 0.0f, 0.13f));
+//			ups->setColor(Vec4f(0.115f, 0.115f, 0.115f, 0.22f));
+//			ups->setPos(result->getCurrVector());
+//			ups->setBlendMode(ups->strToBlendMode("black"));
+//			ups->setOffset(Vec3f(0,2,0));
+//			ups->setDirection(Vec3f(0,1,-0.2f));
+//			ups->setRadius(result->type->getSize()/3.f);
+//			ups->setShape(Shared::Graphics::UnitParticleSystem::sLinear);
+//			ups->setTexture(CoreData::getInstance().getFireTexture());
+//			const Game *game = Renderer::getInstance().getGame();
+//			ups->setSpeed(2.0f / game->getWorld()->getUpdateFps(result->getFactionIndex()));
+//			ups->setGravity(0.0004f);
+//			ups->setEmissionRate(1);
+//			ups->setMaxParticleEnergy(150);
+//			ups->setSizeNoEnergy(result->type->getSize()*0.6f);
+//			ups->setParticleSize(result->type->getSize()*0.8f);
+//			result->smokeParticleSystems.push_back(ups);
+
+			//Renderer::getInstance().manageParticleSystem(result->fire, rsGame);
 			Renderer::getInstance().addToDeferredParticleSystemList(make_pair(ups, rsGame));
+
 			//printf("Loading smoke particles:\n[%s]\n",ups->toString().c_str());
 		}
 	}

source/glest_game/type_instances/unit.h

@@ -368,7 +368,7 @@ private:
     Vec2i pos;
 	Vec2i lastPos;
     Vec2i targetPos;		//absolute target pos
-	Vec3d targetVec;
+	Vec3f targetVec;
 	Vec2i meetingPos;
 
 	double lastRotation;		//in degrees
@@ -536,7 +536,7 @@ public:
 	double getEpRatio() const;
 	inline bool getToBeUndertaken() const				{return toBeUndertaken;}
 	inline Vec2i getTargetPos() const					{return targetPos;}
-	inline Vec3d getTargetVec() const					{return targetVec;}
+	inline Vec3f getTargetVec() const					{return targetVec;}
 	inline Field getTargetField() const				{return targetField;}
 	inline Vec2i getMeetingPos() const					{return meetingPos;}
 	inline Faction *getFaction() const					{return faction;}
@@ -574,7 +574,7 @@ public:
 	Vec2i getPosWithCellMapSet() const;
 	inline Vec2i getLastPos() const			{return lastPos;}
 	Vec2i getCenteredPos() const;
-    Vec2d getFloatCenteredPos() const;
+    Vec2f getFloatCenteredPos() const;
 	Vec2i getCellPos() const;
 
     //is
@@ -613,7 +613,7 @@ public:
 	void refreshPos();
 	void setTargetPos(const Vec2i &targetPos);
 	void setTarget(const Unit *unit);
-	void setTargetVec(const Vec3d &targetVec);
+	void setTargetVec(const Vec3f &targetVec);
 	void setMeetingPos(const Vec2i &meetingPos);
 	void setVisible(const bool visible);
 	inline bool getVisible() const { return visible; }
@@ -621,9 +621,9 @@ public:
 	//render related
     const Model *getCurrentModel();
     Model *getCurrentModelPtr();
-	Vec3d getCurrVector() const;
-	Vec3d getCurrVectorFlat() const;
-	Vec3d getVectorFlat(const Vec2i &lastPosValue, const Vec2i &curPosValue) const;
+	Vec3f getCurrVector() const;
+	Vec3f getCurrVectorFlat() const;
+	Vec3f getVectorFlat(const Vec2i &lastPosValue, const Vec2i &curPosValue) const;
 
     //command related
 	bool anyCommand(bool validateCommandtype=false) const;

source/glest_game/types/skill_type.cpp

@@ -140,7 +140,7 @@ bool AttackBoost::isAffected(const Unit *source, const Unit *dest) const {
 		}
 
 		if(destUnitMightApply == true) {
-			double distance = source->getCenteredPos().dist(dest->getCenteredPos());
+			float distance = source->getCenteredPos().dist(dest->getCenteredPos());
 			if(distance <= radius) {
 				result = true;
 			}
@@ -516,7 +516,7 @@ const AnimationAttributes SkillType::getAnimationAttribute(int index) const {
 	return animationAttributes[index];
 }
 
-Model *SkillType::getAnimation(double animProgress, const Unit *unit,
+Model *SkillType::getAnimation(float animProgress, const Unit *unit,
 		int *lastAnimationIndex, int *animationRandomCycleCount) const {
 	int modelIndex = 0;
 	//printf("Count [%d] animProgress = [%f] for skill [%s] animationRandomCycleCount = %d\n",animations.size(),animProgress,name.c_str(),*animationRandomCycleCount);
@@ -665,7 +665,7 @@ void SkillType::saveGame(XmlNode *rootNode) {
 //
 //    SoundContainer sounds;
 //	float soundStartTime;
-	skillTypeNode->addAttribute("soundStartTime",doubleToStr(soundStartTime,16), mapTagReplacements);
+	skillTypeNode->addAttribute("soundStartTime",floatToStr(soundStartTime,16), mapTagReplacements);
 //	RandomGen random;
 	skillTypeNode->addAttribute("random",intToStr(random.getLastNumber()), mapTagReplacements);
 //	AttackBoost attackBoost;
@@ -897,7 +897,7 @@ void AttackSkillType::saveGame(XmlNode *rootNode) {
 		attackFieldsNode->addAttribute("value",intToStr(attackFields[i]), mapTagReplacements);
 	}
 //	float attackStartTime;
-	attackSkillTypeNode->addAttribute("attackStartTime",doubleToStr(attackStartTime,16), mapTagReplacements);
+	attackSkillTypeNode->addAttribute("attackStartTime",floatToStr(attackStartTime,16), mapTagReplacements);
 //	string spawnUnit;
 	attackSkillTypeNode->addAttribute("spawnUnit",spawnUnit, mapTagReplacements);
 //	int spawnUnitcount;
@@ -1220,7 +1220,7 @@ void FogOfWarSkillType::saveGame(XmlNode *rootNode) {
 
 	fogSkillTypeNode->addAttribute("enable-fog",intToStr(fowEnable), mapTagReplacements);
 	fogSkillTypeNode->addAttribute("apply-team",intToStr(applyToTeam), mapTagReplacements);
-	fogSkillTypeNode->addAttribute("duration",doubleToStr(durationTime,16), mapTagReplacements);
+	fogSkillTypeNode->addAttribute("duration",floatToStr(durationTime,16), mapTagReplacements);
 }
 
 // =====================================================

source/glest_game/types/skill_type.h

@@ -137,7 +137,7 @@ protected:
     vector<AnimationAttributes> animationAttributes;
 
     SoundContainer sounds;
-	double soundStartTime;
+	float soundStartTime;
 	RandomGen random;
 	AttackBoost attackBoost;
 
@@ -175,9 +175,9 @@ public:
 	int getHpCost() const				{return hpCost;}
 	int getSpeed() const				{return speed;}
 	int getAnimSpeed() const			{return animSpeed;}
-	Model *getAnimation(double animProgress=0, const Unit *unit=NULL, int *lastAnimationIndex=NULL, int *animationRandomCycleCount=NULL) const;
+	Model *getAnimation(float animProgress=0, const Unit *unit=NULL, int *lastAnimationIndex=NULL, int *animationRandomCycleCount=NULL) const;
 	StaticSound *getSound() const		{return sounds.getRandSound();}
-	double getSoundStartTime() const		{return soundStartTime;}
+	float getSoundStartTime() const		{return soundStartTime;}
 	
 	bool isAttackBoostEnabled() const { return attackBoost.enabled; }
 	const AttackBoost * getAttackBoost() const { return &attackBoost; }
@@ -226,7 +226,7 @@ private:
     int attackRange;
 	const AttackType *attackType;
 	bool attackFields[fieldCount];
-	double attackStartTime;
+	float attackStartTime;
 
 	string spawnUnit;
 	int spawnUnitcount;
@@ -253,7 +253,7 @@ public:
 	inline int getAttackRange() const					{return attackRange;}
 	inline const AttackType *getAttackType() const		{return attackType;}
 	inline bool getAttackField(Field field) const		{return attackFields[field];}
-	inline double getAttackStartTime() const			{return attackStartTime;}
+	inline float getAttackStartTime() const			{return attackStartTime;}
 	inline string getSpawnUnit() const					{return spawnUnit;}
 	inline int getSpawnUnitCount() const				{return spawnUnitcount;}
 
@@ -419,13 +419,13 @@ class FogOfWarSkillType: public SkillType {
 private:
 	bool fowEnable;
 	bool applyToTeam;
-	double durationTime;
+	float durationTime;
 
 public:
 	FogOfWarSkillType();
     bool getFowEnable() const	{return fowEnable;}
     bool getApplyToTeam() const	{return applyToTeam;}
-    double getDurationTime() const	{return durationTime;}
+    float getDurationTime() const	{return durationTime;}
 
 	virtual void load(const XmlNode *sn, const XmlNode *attackBoostsNode, const string &dir, const TechTree *tt,
 			const FactionType *ft, std::map<string,vector<pair<string, string> > > &loadedFileList,

source/glest_game/world/map.cpp

@@ -481,7 +481,7 @@ Checksum Map::load(const string &path, TechTree *techTree, Tileset *tileset) {
 						sc->setObject(NULL);
 					}
 					else if(objNumber <= Tileset::objCount) {
-						Object *o= new Object(tileset->getObjectType(objNumber-1), Vec3d(sc->getVertex()),Vec2i(i, j));
+						Object *o= new Object(tileset->getObjectType(objNumber-1), sc->getVertex(),Vec2i(i, j));
 						sc->setObject(o);
 						for(int k = 0; k < techTree->getResourceTypeCount(); ++k) {
 							const ResourceType *rt= techTree->getResourceType(k);
@@ -492,7 +492,7 @@ Checksum Map::load(const string &path, TechTree *techTree, Tileset *tileset) {
 					}
 					else{
 						const ResourceType *rt= techTree->getTechResourceType(objNumber - Tileset::objCount) ;
-						Object *o= new Object(NULL, Vec3d(sc->getVertex()),Vec2i(i, j));
+						Object *o= new Object(NULL, sc->getVertex(),Vec2i(i, j));
 						o->setResource(rt, Vec2i(i, j));
 						sc->setObject(o);
 					}
@@ -1641,8 +1641,8 @@ void Map::smoothSurface(Tileset *tileset) {
 						}
 						if (formerObject == NULL) {
 							Object *o = new Object(tileset->getObjectType(9),
-									Vec3d(getSurfaceCell(i, j)->getVertex()),
-									Vec2i(i,j));
+									getSurfaceCell(i, j)->getVertex(), Vec2i(i,
+											j));
 							getSurfaceCell(i, j)->setObject(o);
 						}
 					}

source/glest_game/world/time_flow.cpp

@@ -74,7 +74,7 @@ void TimeFlow::update() {
 		}
 		UnitParticleSystem::isNight=false;
 	}
-	UnitParticleSystem::lightColor = Vec3d(computeLightColor());
+	UnitParticleSystem::lightColor=computeLightColor();
 
 	if((lastTime<dawn && time>=dawn) || firstTime){
 		

source/glest_game/world/unit_updater.cpp

@@ -119,11 +119,11 @@ bool UnitUpdater::updateUnit(Unit *unit) {
 	//play skill sound
 	const SkillType *currSkill= unit->getCurrSkill();
 	if(currSkill->getSound() != NULL) {
-		double soundStartTime= currSkill->getSoundStartTime();
+		float soundStartTime= currSkill->getSoundStartTime();
 		if(soundStartTime >= unit->getLastAnimProgressAsFloat() && soundStartTime < unit->getAnimProgressAsFloat()) {
 			if(map->getSurfaceCell(Map::toSurfCoords(unit->getPos()))->isVisible(world->getThisTeamIndex()) ||
 				(game->getWorld()->showWorldForPlayer(game->getWorld()->getThisTeamIndex()) == true)) {
-				soundRenderer.playFx(currSkill->getSound(), Vec3f(unit->getCurrVector()), gameCamera->getPos());
+				soundRenderer.playFx(currSkill->getSound(), unit->getCurrVector(), gameCamera->getPos());
 			}
 		}
 	}
@@ -275,7 +275,7 @@ bool UnitUpdater::updateUnit(Unit *unit) {
 				if(Config::getInstance().getBool("DisableWaterSounds","false") == false) {
 					soundRenderer.playFx(
 						CoreData::getInstance().getWaterSound(),
-						Vec3f(unit->getCurrVector()),
+						unit->getCurrVector(),
 						gameCamera->getPos()
 					);
 
@@ -930,7 +930,7 @@ void UnitUpdater::updateBuild(Unit *unit, int frameIndex) {
 						(game->getWorld()->showWorldForPlayer(game->getWorld()->getThisTeamIndex()) == true)) {
 						SoundRenderer::getInstance().playFx(
 							bct->getStartSound(),
-							Vec3f(unit->getCurrVector()),
+							unit->getCurrVector(),
 							gameCamera->getPos());
 					}
 
@@ -1022,7 +1022,7 @@ void UnitUpdater::updateBuild(Unit *unit, int frameIndex) {
 					(game->getWorld()->showWorldForPlayer(game->getWorld()->getThisTeamIndex()) == true)) {
 					SoundRenderer::getInstance().playFx(
 						bct->getBuiltSound(),
-						Vec3f(unit->getCurrVector()),
+						unit->getCurrVector(),
 						gameCamera->getPos());
 				}
 			}
@@ -2295,8 +2295,8 @@ void UnitUpdater::startAttackParticleSystem(Unit *unit){
 	ParticleSystemTypeProjectile *pstProj= ast->getProjParticleType();
 	ParticleSystemTypeSplash *pstSplash= ast->getSplashParticleType();
 
-	Vec3d startPos= unit->getCurrVector();
-	Vec3d endPos= unit->getTargetVec();
+	Vec3f startPos= unit->getCurrVector();
+	Vec3f endPos= unit->getTargetVec();
 
 	//make particle system
 	const SurfaceCell *sc= map->getSurfaceCell(Map::toSurfCoords(unit->getPos()));
@@ -2313,7 +2313,7 @@ void UnitUpdater::startAttackParticleSystem(Unit *unit){
 		psProj->setObserver(new ParticleDamager(unit, this, gameCamera));
 		psProj->setVisible(visible);
 		if(unit->getFaction()->getTexture()) {
-			psProj->setFactionColor(Vec3d(unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+			psProj->setFactionColor(unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 		}
 		renderer.manageParticleSystem(psProj, rsGame);
 		unit->addAttackParticleSystem(psProj);
@@ -2328,7 +2328,7 @@ void UnitUpdater::startAttackParticleSystem(Unit *unit){
 		psSplash->setPos(endPos);
 		psSplash->setVisible(visible);
 		if(unit->getFaction()->getTexture()) {
-			psSplash->setFactionColor(Vec3d(unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0)));
+			psSplash->setFactionColor(unit->getFaction()->getTexture()->getPixmapConst()->getPixel3f(0,0));
 		}
 		renderer.manageParticleSystem(psSplash, rsGame);
 		if(pstProj!=NULL){
@@ -2489,7 +2489,7 @@ bool UnitUpdater::unitOnRange(Unit *unit, int range, Unit **rangedPtr,
 	//aux vars
 	int size 			= unit->getType()->getSize();
 	Vec2i center 		= unit->getPos();
-	Vec2d floatCenter	= unit->getFloatCenteredPos();
+	Vec2f floatCenter	= unit->getFloatCenteredPos();
 
 	//bool foundInCache = true;
 	if(findCachedCellsEnemies(center,range,size,enemies,ast,
@@ -2501,9 +2501,9 @@ bool UnitUpdater::unitOnRange(Unit *unit, int range, Unit **rangedPtr,
 			for(int j = center.y - range; j < center.y + range + size; ++j) {
 				//cells inside map and in range
 #ifdef USE_STREFLOP
-				if(map->isInside(i, j) && streflop::floor(static_cast<streflop::Simple>(floatCenter.dist(Vec2d((double)i, (double)j)))) <= (range+1)){
+				if(map->isInside(i, j) && streflop::floor(static_cast<streflop::Simple>(floatCenter.dist(Vec2f((float)i, (float)j)))) <= (range+1)){
 #else
-				if(map->isInside(i, j) && floor(floatCenter.dist(Vec2d((double)i, (double)j))) <= (range+1)){
+				if(map->isInside(i, j) && floor(floatCenter.dist(Vec2f((float)i, (float)j))) <= (range+1)){
 #endif
 					Cell *cell = map->getCell(i,j);
 					findEnemiesForCell(ast,cell,unit,commandTarget,enemies);
@@ -2594,7 +2594,7 @@ bool UnitUpdater::unitOnRange(Unit *unit, int range, Unit **rangedPtr,
 
 		if(evalMode == false && onlyEnemyUnits == false &&
 			enemyUnit->getTeam() != world->getThisTeamIndex()) {
-			Vec2d enemyFloatCenter	= enemyUnit->getFloatCenteredPos();
+			Vec2f enemyFloatCenter	= enemyUnit->getFloatCenteredPos();
 			// find nearest Attack and cleanup old dates
 			AttackWarningData *nearest	= NULL;
 			double currentDistance		= 0.f;
@@ -2683,7 +2683,7 @@ vector<Unit*> UnitUpdater::enemyUnitsOnRange(const Unit *unit,const AttackSkillT
 	//aux vars
 	int size 			= unit->getType()->getSize();
 	Vec2i center 		= unit->getPosNotThreadSafe();
-	Vec2d floatCenter	= unit->getFloatCenteredPos();
+	Vec2f floatCenter	= unit->getFloatCenteredPos();
 
 	//bool foundInCache = true;
 	if(findCachedCellsEnemies(center,range,size,enemies,ast,
@@ -2695,9 +2695,9 @@ vector<Unit*> UnitUpdater::enemyUnitsOnRange(const Unit *unit,const AttackSkillT
 			for(int j = center.y - range; j < center.y + range + size; ++j) {
 				//cells inside map and in range
 #ifdef USE_STREFLOP
-				if(map->isInside(i, j) && streflop::floor(static_cast<streflop::Simple>(floatCenter.dist(Vec2d((double)i, (double)j)))) <= (range+1)){
+				if(map->isInside(i, j) && streflop::floor(static_cast<streflop::Simple>(floatCenter.dist(Vec2f((float)i, (float)j)))) <= (range+1)){
 #else
-				if(map->isInside(i, j) && floor(floatCenter.dist(Vec2d((double)i, (double)j))) <= (range+1)){
+				if(map->isInside(i, j) && floor(floatCenter.dist(Vec2f((float)i, (float)j))) <= (range+1)){
 #endif
 					Cell *cell = map->getCell(i,j);
 					findEnemiesForCell(ast,cell,unit,commandTarget,enemies);
@@ -2743,7 +2743,7 @@ vector<Unit*> UnitUpdater::findUnitsInRange(const Unit *unit, int radius) {
 	//aux vars
 	int size 			= unit->getType()->getSize();
 	Vec2i center 		= unit->getPosNotThreadSafe();
-	Vec2d floatCenter	= unit->getFloatCenteredPos();
+	Vec2f floatCenter	= unit->getFloatCenteredPos();
 
 	//nearby cells
 	//UnitRangeCellsLookupItem cacheItem;
@@ -2751,9 +2751,9 @@ vector<Unit*> UnitUpdater::findUnitsInRange(const Unit *unit, int radius) {
 		for(int j = center.y - range; j < center.y + range + size; ++j) {
 			//cells inside map and in range
 #ifdef USE_STREFLOP
-			if(map->isInside(i, j) && streflop::floor(static_cast<streflop::Simple>(floatCenter.dist(Vec2d((double)i, (double)j)))) <= (range+1)){
+			if(map->isInside(i, j) && streflop::floor(static_cast<streflop::Simple>(floatCenter.dist(Vec2f((float)i, (float)j)))) <= (range+1)){
 #else
-			if(map->isInside(i, j) && floor(floatCenter.dist(Vec2d((double)i, (double)j))) <= (range+1)){
+			if(map->isInside(i, j) && floor(floatCenter.dist(Vec2f((float)i, (float)j))) <= (range+1)){
 #endif
 				Cell *cell = map->getCell(i,j);
 				findUnitsForCell(cell,unit,units);
@@ -2865,7 +2865,7 @@ void ParticleDamager::update(ParticleSystem *particleSystem) {
 		//play sound
 		StaticSound *projSound= ast->getProjSound();
 		if(particleSystem->getVisible() && projSound != NULL) {
-			SoundRenderer::getInstance().playFx(projSound, Vec3f(attacker->getCurrVector()), gameCamera->getPos());
+			SoundRenderer::getInstance().playFx(projSound, attacker->getCurrVector(), gameCamera->getPos());
 		}
 	}
 	particleSystem->setObserver(NULL);

source/glest_game/world/unit_updater.h

@@ -55,7 +55,7 @@ public:
 
 class AttackWarningData {
 public:
-	Vec2d attackPosition;
+	Vec2f attackPosition;
 	int lastFrameCount;
 };
 
@@ -81,7 +81,7 @@ private:
 	Game *game;
 	//RandomGen random;
 	Mutex mutexAttackWarnings;
-	double attackWarnRange;
+	float attackWarnRange;
 	AttackWarnings attackWarnings;
 
 	Mutex mutexUnitRangeCellsLookupItemCache;

source/shared_lib/include/graphics/particle.h

@@ -45,11 +45,11 @@ class Model;
 class Particle {
 public:	
 	//attributes
-	Vec3d pos;
-	Vec3d lastPos;
-	Vec3d speed;
-	Vec3d accel;
-	Vec4d color;
+	Vec3f pos;
+	Vec3f lastPos;
+	Vec3f speed;
+	Vec3f accel;
+	Vec4f color;
 	double size;
 	int energy;
 
@@ -59,14 +59,11 @@ public:
 		energy = 0;
 	}
 	//get
-	Vec3d getPos() const		{return pos;}
-	Vec3f getPosAsFloat() const	{return Vec3f(pos.x,pos.y,pos.z);}
-	Vec3d getLastPos() const	{return lastPos;}
-	Vec3f getLastPosAsFloat() const	{return Vec3f(lastPos.x,lastPos.y,lastPos.z);}
-	Vec3d getSpeed() const		{return speed;}
-	Vec3d getAccel() const		{return accel;}
-	Vec4d getColor() const		{return color;}
-	Vec4f getColorAsFloat() const {return Vec4f(color.x,color.y,color.z,color.w);}
+	Vec3f getPos() const		{return pos;}
+	Vec3f getLastPos() const	{return lastPos;}
+	Vec3f getSpeed() const		{return speed;}
+	Vec3f getAccel() const		{return accel;}
+	Vec4f getColor() const		{return color;}
 	double getSize() const		{return size;}
 	int getEnergy()	const		{return energy;}
 
@@ -88,7 +85,6 @@ public:
 
 class ParticleOwner {
 public:
-	virtual ~ParticleOwner() {};
 	virtual void end(ParticleSystem *particleSystem)= 0;
 };
 
@@ -97,6 +93,7 @@ public:
 // =====================================================
 
 class ParticleSystem {
+
 public:
 
 enum State {
@@ -138,16 +135,16 @@ protected:
 	int textureFileLoadDeferredComponents;
 
 	Texture *texture;
-	Vec3d pos;
-	Vec4d color;
-	Vec4d colorNoEnergy;
+	Vec3f pos;
+	Vec4f color;
+	Vec4f colorNoEnergy;
 	double emissionRate;
 	double emissionState;
 	int maxParticleEnergy;
 	int varParticleEnergy;
 	double particleSize;
 	double speed;
-	Vec3d factionColor;
+	Vec3f factionColor;
     bool teamcolorNoEnergy;
     bool teamcolorEnergy;
 	int alternations;
@@ -169,8 +166,7 @@ public:
 	State getState() const						{return state;}
 	BlendMode getBlendMode() const				{return blendMode;}
 	Texture *getTexture() const					{return texture;}
-	Vec3d getPos() const						{return pos;}
-	Vec3f getPosAsFloat() const	{return Vec3f(pos.x,pos.y,pos.z);}
+	Vec3f getPos() const						{return pos;}
 	Particle *getParticle(int i)				{return &particles[i];}
 	const Particle *getParticle(int i) const	{return &particles[i];}
 	int getAliveParticleCount() const			{return aliveParticleCount;}
@@ -185,9 +181,9 @@ public:
 	//set
 	virtual void setState(State state);
 	void setTexture(Texture *texture);
-	virtual void setPos(Vec3d pos);
-	void setColor(Vec4d color);
-	void setColorNoEnergy(Vec4d color);
+	virtual void setPos(Vec3f pos);
+	void setColor(Vec4f color);
+	void setColorNoEnergy(Vec4f color);
 	void setEmissionRate(double emissionRate);
 	void setMaxParticleEnergy(int maxParticleEnergy);
 	void setVarParticleEnergy(int varParticleEnergy);
@@ -201,7 +197,7 @@ public:
 	void setTeamcolorEnergy(bool teamcolorEnergy)		{this->teamcolorEnergy= teamcolorEnergy;}
 	void setAlternations(int alternations)				{this->alternations= alternations;}
 	void setParticleSystemStartDelay(int delay)			{this->particleSystemStartDelay= delay;}
-	virtual void setFactionColor(Vec3d factionColor);
+	virtual void setFactionColor(Vec3f factionColor);
 
 	static BlendMode strToBlendMode(const string &str);
 	//misc
@@ -241,7 +237,7 @@ protected:
 class FireParticleSystem: public ParticleSystem{
 private:
 	double radius;
-	Vec3d windSpeed;
+	Vec3f windSpeed;
 
 public:
 	FireParticleSystem(int particleCount= 2000);
@@ -284,8 +280,8 @@ public:
 	ParticleSystem* getChild(int i);
 	void addChild(UnitParticleSystem* child);
 	void removeChild(UnitParticleSystem* child);
-	void setPos(Vec3d pos);
-	void setOffset(Vec3d offset);
+	void setPos(Vec3f pos);
+	void setOffset(Vec3f offset);
 	void setModel(Model *model) {this->model= model;}
 	virtual void render(ParticleRenderer *pr, ModelRenderer *mr);
 	double getTween() { return tween; }  // 0.0 -> 1.0 for animation of model
@@ -293,8 +289,7 @@ public:
 	virtual string getModelFileLoadDeferred();
 
 	void setPrimitive(Primitive primitive) {this->primitive= primitive;}
-	Vec3d getDirection() const {return direction;}
-	Vec3f getDirectionAsFloat() const {return Vec3f(direction.x, direction.y, direction.z);}
+	Vec3f getDirection() const {return direction;}
 	void setModelCycle(double modelCycle) {this->modelCycle= modelCycle;}
 
 	virtual void saveGame(XmlNode *rootNode);
@@ -312,8 +307,8 @@ protected:
 	string modelFileLoadDeferred;
 	Model *model;
 	double modelCycle;
-	Vec3d offset;
-	Vec3d direction;
+	Vec3f offset;
+	Vec3f direction;
 	double tween;
 	
 	GameParticleSystem(int particleCount);
@@ -328,14 +323,14 @@ protected:
 class UnitParticleSystem: public GameParticleSystem{
 public:
 	static bool isNight;
-	static Vec3d lightColor;
+	static Vec3f lightColor;
 private:
 	double radius;
 	double minRadius;
-	Vec3d windSpeed;
-	Vec3d cRotation;
-	Vec3d fixedAddition;
-    Vec3d oldPosition;
+	Vec3f windSpeed;
+	Vec3f cRotation;
+	Vec3f fixedAddition;
+    Vec3f oldPosition;
     bool energyUp;
     double startTime;
     double endTime;
@@ -390,7 +385,7 @@ public:
 
 	void setWind(double windAngle, double windSpeed);
 	
-	void setDirection(Vec3d direction)				{this->direction= direction;}
+	void setDirection(Vec3f direction)				{this->direction= direction;}
 	void setSizeNoEnergy(double sizeNoEnergy)			{this->sizeNoEnergy= sizeNoEnergy;}
 	void setGravity(double gravity)						{this->gravity= gravity;}
 	void setRotation(double rotation);
@@ -409,7 +404,7 @@ public:
 	void setLifetime(int lifetime)					{this->lifetime= lifetime;}
 	void setParent(GameParticleSystem* parent)			{this->parent= parent;}
 	GameParticleSystem* getParent() const				{return parent;}
-	void setParentDirection(Vec3d parentDirection);
+	void setParentDirection(Vec3f parentDirection);
 	
 	static Shape strToShape(const string& str);
 
@@ -427,7 +422,7 @@ public:
 
 class RainParticleSystem: public ParticleSystem{
 private:
-	Vec3d windSpeed;
+	Vec3f windSpeed;
 	double radius;
 
 public:
@@ -454,7 +449,7 @@ public:
 
 class SnowParticleSystem: public ParticleSystem{
 private:
-	Vec3d windSpeed;
+	Vec3f windSpeed;
 	double radius;
 
 public:
@@ -519,14 +514,14 @@ public:
 private:
 	SplashParticleSystem *nextParticleSystem;
 
-	Vec3d lastPos;
-	Vec3d startPos;
-	Vec3d endPos;
-	Vec3d flatPos;
+	Vec3f lastPos;
+	Vec3f startPos;
+	Vec3f endPos;
+	Vec3f flatPos;
 
-	Vec3d xVector;
-	Vec3d yVector;
-	Vec3d zVector;
+	Vec3f xVector;
+	Vec3f yVector;
+	Vec3f zVector;
 
 	Trajectory trajectory;
 	double trajectorySpeed;
@@ -555,7 +550,7 @@ public:
 	void setTrajectoryScale(double trajectoryScale)			{this->trajectoryScale= trajectoryScale;}
 	void setTrajectoryFrequency(double trajectoryFrequency)	{this->trajectoryFrequency= trajectoryFrequency;}
 
-	void setPath(Vec3d startPos, Vec3d endPos);
+	void setPath(Vec3f startPos, Vec3f endPos);
 
 	static Trajectory strToTrajectory(const string &str);
 

source/shared_lib/sources/graphics/gl/particle_renderer_gl.cpp

@@ -109,8 +109,8 @@ void ParticleRendererGl::renderSystem(ParticleSystem *ps){
 	for(int i=0; i<ps->getAliveParticleCount(); ++i){
 		const Particle *particle= ps->getParticle(i);
 		float size= particle->getSize()/2.0f;
-		Vec3f pos= particle->getPosAsFloat();
-		Vec4f color= particle->getColorAsFloat();
+		Vec3f pos= particle->getPos();
+		Vec4f color= particle->getColor();
 
 		vertexBuffer[bufferIndex] = pos - (rightVector - upVector) * size;
 		vertexBuffer[bufferIndex+1] = pos - (rightVector + upVector) * size;
@@ -157,10 +157,10 @@ void ParticleRendererGl::renderSystemLine(ParticleSystem *ps){
 
 		for(int i=0; i<ps->getAliveParticleCount(); ++i){
 			particle= ps->getParticle(i);
-			Vec4f color= particle->getColorAsFloat();
+			Vec4f color= particle->getColor();
 
-			vertexBuffer[bufferIndex] = particle->getPosAsFloat();
-			vertexBuffer[bufferIndex+1] = particle->getLastPosAsFloat();
+			vertexBuffer[bufferIndex] = particle->getPos();
+			vertexBuffer[bufferIndex+1] = particle->getLastPos();
 
 			colorBuffer[bufferIndex]= color;
 			colorBuffer[bufferIndex+1]= color;
@@ -201,10 +201,10 @@ void ParticleRendererGl::renderSystemLineAlpha(ParticleSystem *ps){
 
 		for(int i=0; i<ps->getAliveParticleCount(); ++i){
 			particle= ps->getParticle(i);
-			Vec4f color= particle->getColorAsFloat();
+			Vec4f color= particle->getColor();
 
-			vertexBuffer[bufferIndex] = particle->getPosAsFloat();
-			vertexBuffer[bufferIndex+1] = particle->getLastPosAsFloat();
+			vertexBuffer[bufferIndex] = particle->getPos();
+			vertexBuffer[bufferIndex+1] = particle->getLastPos();
 
 			colorBuffer[bufferIndex]= color;
 			colorBuffer[bufferIndex+1]= color;
@@ -236,11 +236,11 @@ void ParticleRendererGl::renderModel(GameParticleSystem *ps, ModelRenderer *mr){
 		glPushMatrix();
 
 		//translate
-		Vec3f pos= ps->getPosAsFloat();
+		Vec3f pos= ps->getPos();
 		glTranslatef(pos.x, pos.y, pos.z);
 
 		//rotate
-		Vec3f direction= ps->getDirectionAsFloat();
+		Vec3f direction= ps->getDirection();
 		Vec3f flatDirection= Vec3f(direction.x, 0.f, direction.z);
 		Vec3f rotVector= Vec3f(0.f, 1.f, 0.f).cross(flatDirection);
 

source/shared_lib/sources/graphics/particle.cpp

@@ -65,15 +65,15 @@ void Particle::loadGame(const XmlNode *rootNode) {
 
 	//particleNode = aiNode->getAttribute("startLoc")->getIntValue();
 	//	Vec3f pos;
-	pos = Vec3d::strToVec3(particleNode->getAttribute("pos")->getValue());
+	pos = Vec3f::strToVec3(particleNode->getAttribute("pos")->getValue());
 	//	Vec3f lastPos;
-	lastPos = Vec3d::strToVec3(particleNode->getAttribute("lastPos")->getValue());
+	lastPos = Vec3f::strToVec3(particleNode->getAttribute("lastPos")->getValue());
 	//	Vec3f speed;
-	speed = Vec3d::strToVec3(particleNode->getAttribute("speed")->getValue());
+	speed = Vec3f::strToVec3(particleNode->getAttribute("speed")->getValue());
 	//	Vec3f accel;
-	accel = Vec3d::strToVec3(particleNode->getAttribute("accel")->getValue());
+	accel = Vec3f::strToVec3(particleNode->getAttribute("accel")->getValue());
 	//	Vec4f color;
-	color = Vec4d::strToVec4(particleNode->getAttribute("color")->getValue());
+	color = Vec4f::strToVec4(particleNode->getAttribute("color")->getValue());
 	//	float size;
 	size = particleNode->getAttribute("size")->getFloatValue();
 	//	int energy;
@@ -112,9 +112,9 @@ ParticleSystem::ParticleSystem(int particleCount) {
 	//this->particleCount= particles.size();
 	maxParticleEnergy= 250;
 	varParticleEnergy= 50;
-	pos= Vec3d(0.0f);
-	color= Vec4d(1.0f);
-	colorNoEnergy= Vec4d(0.0f);
+	pos= Vec3f(0.0f);
+	color= Vec4f(1.0f);
+	colorNoEnergy= Vec4f(0.0f);
 	emissionRate= 15.0f;
 	emissionState= 1.0f; // initialized with 1 because we must have at least one particle in the beginning!
 	speed= 1.0f;
@@ -251,17 +251,17 @@ void ParticleSystem::setTexture(Texture *texture){
 	this->texture= texture;
 }
 
-void ParticleSystem::setPos(Vec3d pos){
+void ParticleSystem::setPos(Vec3f pos){
 	this->pos= pos;
 	for(int i=getChildCount()-1; i>=0; i--)
 		getChild(i)->setPos(pos);
 }
 
-void ParticleSystem::setColor(Vec4d color){
+void ParticleSystem::setColor(Vec4f color){
 	this->color= color;
 }
 
-void ParticleSystem::setColorNoEnergy(Vec4d colorNoEnergy){
+void ParticleSystem::setColorNoEnergy(Vec4f colorNoEnergy){
 	this->colorNoEnergy= colorNoEnergy;
 }
 
@@ -485,11 +485,11 @@ void ParticleSystem::loadGame(const XmlNode *rootNode) {
 	}
 
 	//	Vec3f pos;
-	pos = Vec3d::strToVec3(particleSystemNode->getAttribute("pos")->getValue());
+	pos = Vec3f::strToVec3(particleSystemNode->getAttribute("pos")->getValue());
 	//	Vec4f color;
-	color = Vec4d::strToVec4(particleSystemNode->getAttribute("color")->getValue());
+	color = Vec4f::strToVec4(particleSystemNode->getAttribute("color")->getValue());
 	//	Vec4f colorNoEnergy;
-	colorNoEnergy = Vec4d::strToVec4(particleSystemNode->getAttribute("colorNoEnergy")->getValue());
+	colorNoEnergy = Vec4f::strToVec4(particleSystemNode->getAttribute("colorNoEnergy")->getValue());
 	//	float emissionRate;
 	emissionRate = particleSystemNode->getAttribute("emissionRate")->getFloatValue();
 	//	float emissionState;
@@ -503,7 +503,7 @@ void ParticleSystem::loadGame(const XmlNode *rootNode) {
 	//	float speed;
 	speed = particleSystemNode->getAttribute("speed")->getFloatValue();
 	//	Vec3f factionColor;
-	factionColor = Vec3d::strToVec3(particleSystemNode->getAttribute("factionColor")->getValue());
+	factionColor = Vec3f::strToVec3(particleSystemNode->getAttribute("factionColor")->getValue());
 	//    bool teamcolorNoEnergy;
 	teamcolorNoEnergy = particleSystemNode->getAttribute("teamcolorNoEnergy")->getIntValue() != 0;
 	//    bool teamcolorEnergy;
@@ -601,9 +601,9 @@ Particle * ParticleSystem::createParticle(){
 void ParticleSystem::initParticle(Particle *p, int particleIndex){
 	p->pos= pos;
 	p->lastPos= p->pos;
-	p->speed= Vec3d(0.0f);
-	p->accel= Vec3d(0.0f);
-	p->color= Vec4d(1.0f, 1.0f, 1.0f, 1.0);
+	p->speed= Vec3f(0.0f);
+	p->accel= Vec3f(0.0f);
+	p->color= Vec4f(1.0f, 1.0f, 1.0f, 1.0);
 	p->size= particleSize;
 	p->energy= maxParticleEnergy + random.randRange(-varParticleEnergy, varParticleEnergy);
 }
@@ -623,15 +623,15 @@ void ParticleSystem::killParticle(Particle *p){
 	aliveParticleCount--;
 }
 
-void ParticleSystem::setFactionColor(Vec3d factionColor){
+void ParticleSystem::setFactionColor(Vec3f factionColor){
 	this->factionColor= factionColor;
-	Vec3d tmpCol;
+	Vec3f tmpCol;
 
 	if(teamcolorEnergy){
-		this->color= Vec4d(factionColor.x, factionColor.y, factionColor.z, this->color.w);
+		this->color= Vec4f(factionColor.x, factionColor.y, factionColor.z, this->color.w);
 	}
 	if(teamcolorNoEnergy){
-		this->colorNoEnergy= Vec4d(factionColor.x, factionColor.y, factionColor.z, this->colorNoEnergy.w);
+		this->colorNoEnergy= Vec4f(factionColor.x, factionColor.y, factionColor.z, this->colorNoEnergy.w);
 	}
 	for(int i=getChildCount()-1; i>=0; i--)
 		getChild(i)->setFactionColor(factionColor);
@@ -647,10 +647,10 @@ FireParticleSystem::FireParticleSystem(int particleCount) :
 
 	radius= 0.5f;
 	speed= 0.01f;
-	windSpeed= Vec3d(0.0f);
+	windSpeed= Vec3f(0.0f);
 
 	setParticleSize(0.6f);
-	setColorNoEnergy(Vec4d(1.0f, 0.5f, 0.0f, 1.0f));
+	setColorNoEnergy(Vec4f(1.0f, 0.5f, 0.0f, 1.0f));
 }
 
 void FireParticleSystem::initParticle(Particle *p, int particleIndex){
@@ -676,10 +676,10 @@ void FireParticleSystem::initParticle(Particle *p, int particleIndex){
 	p->color= colorNoEnergy * 0.5f + colorNoEnergy * 0.5f * radRatio;
 	p->energy= static_cast<int> (maxParticleEnergy * radRatio)
 	        + random.randRange(-varParticleEnergy, varParticleEnergy);
-	p->pos= Vec3d(pos.x + x, pos.y + random.randRange(-radius / 2, radius / 2), pos.z + y);
+	p->pos= Vec3f(pos.x + x, pos.y + random.randRange(-radius / 2, radius / 2), pos.z + y);
 	p->lastPos= pos;
 	p->size= particleSize;
-	p->speed= Vec3d(0, speed + speed * random.randRange(-0.5f, 0.5f), 0) + windSpeed;
+	p->speed= Vec3f(0, speed + speed * random.randRange(-0.5f, 0.5f), 0) + windSpeed;
 }
 
 void FireParticleSystem::updateParticle(Particle *p){
@@ -744,7 +744,7 @@ void FireParticleSystem::loadGame(const XmlNode *rootNode) {
 //	float radius;
 	radius = fireParticleSystemNode->getAttribute("radius")->getFloatValue();
 //	Vec3f windSpeed;
-	windSpeed = Vec3d::strToVec3(fireParticleSystemNode->getAttribute("windSpeed")->getValue());
+	windSpeed = Vec3f::strToVec3(fireParticleSystemNode->getAttribute("windSpeed")->getValue());
 }
 
 Checksum FireParticleSystem::getCRC() {
@@ -810,18 +810,18 @@ void GameParticleSystem::removeChild(UnitParticleSystem* child){
 	children.erase(it);
 }
 
-void GameParticleSystem::setPos(Vec3d pos){
+void GameParticleSystem::setPos(Vec3f pos){
 	this->pos= pos;
 	positionChildren();
 }
 
 void GameParticleSystem::positionChildren() {
-	Vec3d child_pos = pos - offset;
+	Vec3f child_pos = pos - offset;
 	for(int i=getChildCount()-1; i>=0; i--)
 		getChild(i)->setPos(child_pos);
 }
 
-void GameParticleSystem::setOffset(Vec3d offset){
+void GameParticleSystem::setOffset(Vec3f offset){
 	this->offset= offset;
 	positionChildren();
 }
@@ -952,9 +952,9 @@ void GameParticleSystem::loadGame(const XmlNode *rootNode) {
 	//gameParticleSystemNode->addAttribute("modelCycle",floatToStr(modelCycle), mapTagReplacements);
 	modelCycle = gameParticleSystemNode->getAttribute("modelCycle")->getFloatValue();
 	//	Vec3f offset;
-	offset = Vec3d::strToVec3(gameParticleSystemNode->getAttribute("offset")->getValue());
+	offset = Vec3f::strToVec3(gameParticleSystemNode->getAttribute("offset")->getValue());
 	//	Vec3f direction;
-	direction = Vec3d::strToVec3(gameParticleSystemNode->getAttribute("direction")->getValue());
+	direction = Vec3f::strToVec3(gameParticleSystemNode->getAttribute("direction")->getValue());
 	//	float tween;
 	tween = gameParticleSystemNode->getAttribute("tween")->getFloatValue();
 }
@@ -986,17 +986,17 @@ string GameParticleSystem::toString() const {
 //  UnitParticleSystem
 // ===========================================================================
 bool UnitParticleSystem::isNight= false;
-Vec3d UnitParticleSystem::lightColor=Vec3d(1.0f,1.0f,1.0f);
+Vec3f UnitParticleSystem::lightColor=Vec3f(1.0f,1.0f,1.0f);
 
 UnitParticleSystem::UnitParticleSystem(int particleCount) :
 		GameParticleSystem(particleCount),	parent(NULL) {
 	radius= 0.5f;
 	speed= 0.01f;
-	windSpeed= Vec3d(0.0f);
+	windSpeed= Vec3f(0.0f);
 	minRadius = 0.0;
 
 	setParticleSize(0.6f);
-	setColorNoEnergy(Vec4d(1.0f, 0.5f, 0.0f, 1.0f));
+	setColorNoEnergy(Vec4f(1.0f, 0.5f, 0.0f, 1.0f));
 	sizeNoEnergy=1.0f;
 
 	primitive= pQuad;
@@ -1014,8 +1014,8 @@ UnitParticleSystem::UnitParticleSystem(int particleCount) :
 	isVisibleAtDay= true;
 	isDaylightAffected= false;
 
-	cRotation= Vec3d(1.0f, 1.0f, 1.0f);
-	fixedAddition= Vec3d(0.0f, 0.0f, 0.0f);
+	cRotation= Vec3f(1.0f, 1.0f, 1.0f);
+	fixedAddition= Vec3f(0.0f, 0.0f, 0.0f);
 	//prepare system for given staticParticleCount
 	if(staticParticleCount > 0){
 		emissionState= (double) staticParticleCount;
@@ -1108,7 +1108,7 @@ void UnitParticleSystem::initParticle(Particle *p, int particleIndex){
 	p->lastPos= pos;
 	oldPosition= pos;
 	p->size= particleSize;
-	p->accel= Vec3d(0.0f, -gravity, 0.0f);
+	p->accel= Vec3f(0.0f, -gravity, 0.0f);
 	
 	// work out where we start for our shape (set speed and pos)
 	switch(shape){
@@ -1116,9 +1116,9 @@ void UnitParticleSystem::initParticle(Particle *p, int particleIndex){
 		angle = (double)random.randRange(0,360);
 		// fall through
 	case sConical:{
-		Vec2d horiz = Vec2d(1,0).rotate(ang);
-		Vec2d vert = Vec2d(1,0).rotate(degToRad(angle));
-		Vec3d start = Vec3d(horiz.x*vert.y,vert.x,horiz.y).getNormalized(); // close enough
+		Vec2f horiz = Vec2f(1,0).rotate(ang);
+		Vec2f vert = Vec2f(1,0).rotate(degToRad(angle));
+		Vec3f start = Vec3f(horiz.x*vert.y,vert.x,horiz.y).getNormalized(); // close enough
 		p->speed = start * speed;
 		start = start * random.randRange(minRadius,radius);
 		p->pos = pos + offset + start;
@@ -1133,25 +1133,25 @@ void UnitParticleSystem::initParticle(Particle *p, int particleIndex){
 	#endif
 		const double rad= degToRad(rotation);
 		if(!relative){
-			p->pos= Vec3d(pos.x + x + offset.x, pos.y + random.randRange(-radius / 2, radius / 2) + offset.y, pos.z + y
+			p->pos= Vec3f(pos.x + x + offset.x, pos.y + random.randRange(-radius / 2, radius / 2) + offset.y, pos.z + y
 				+ offset.z);
 		}
 		else{// rotate it according to rotation		
 	#ifdef USE_STREFLOP
-			p->pos= Vec3d(pos.x+x+offset.z*streflop::sinf(static_cast<streflop::Simple>(rad))+offset.x*streflop::cosf(static_cast<streflop::Simple>(rad)), pos.y+random.randRange(-radius/2, radius/2)+offset.y, pos.z+y+(offset.z*streflop::cosf(static_cast<streflop::Simple>(rad))-offset.x*streflop::sinf(static_cast<streflop::Simple>(rad))));
+			p->pos= Vec3f(pos.x+x+offset.z*streflop::sinf(static_cast<streflop::Simple>(rad))+offset.x*streflop::cosf(static_cast<streflop::Simple>(rad)), pos.y+random.randRange(-radius/2, radius/2)+offset.y, pos.z+y+(offset.z*streflop::cosf(static_cast<streflop::Simple>(rad))-offset.x*streflop::sinf(static_cast<streflop::Simple>(rad))));
 	#else
-			p->pos= Vec3d(pos.x + x + offset.z * sinf(rad) + offset.x * cosf(rad), pos.y + random.randRange(-radius / 2,
+			p->pos= Vec3f(pos.x + x + offset.z * sinf(rad) + offset.x * cosf(rad), pos.y + random.randRange(-radius / 2,
 				radius / 2) + offset.y, pos.z + y + (offset.z * cosf(rad) - offset.x * sinf(rad)));
 	#endif
 		}
-		p->speed= Vec3d(direction.x + direction.x * random.randRange(-0.5f, 0.5f), direction.y + direction.y
+		p->speed= Vec3f(direction.x + direction.x * random.randRange(-0.5f, 0.5f), direction.y + direction.y
 			* random.randRange(-0.5f, 0.5f), direction.z + direction.z * random.randRange(-0.5f, 0.5f));
 		p->speed= p->speed * speed;
 		if(relative && relativeDirection){
 	#ifdef USE_STREFLOP
-			p->speed=Vec3d(p->speed.z*streflop::sinf(static_cast<streflop::Simple>(rad))+p->speed.x*streflop::cosf(static_cast<streflop::Simple>(rad)),p->speed.y,(p->speed.z*streflop::cosf(static_cast<streflop::Simple>(rad))-p->speed.x*streflop::sinf(static_cast<streflop::Simple>(rad))));
+			p->speed=Vec3f(p->speed.z*streflop::sinf(static_cast<streflop::Simple>(rad))+p->speed.x*streflop::cosf(static_cast<streflop::Simple>(rad)),p->speed.y,(p->speed.z*streflop::cosf(static_cast<streflop::Simple>(rad))-p->speed.x*streflop::sinf(static_cast<streflop::Simple>(rad))));
 	#else
-			p->speed= Vec3d(p->speed.z * sinf(rad) + p->speed.x * cosf(rad), p->speed.y, (p->speed.z * cosf(rad)
+			p->speed= Vec3f(p->speed.z * sinf(rad) + p->speed.x * cosf(rad), p->speed.y, (p->speed.z * cosf(rad)
 				- p->speed.x * sinf(rad)));
 	#endif
 		}
@@ -1175,7 +1175,7 @@ void UnitParticleSystem::update(){
 		}
 	}
 	if(fixed){
-		fixedAddition= Vec3d(pos.x - oldPosition.x, pos.y - oldPosition.y, pos.z - oldPosition.z);
+		fixedAddition= Vec3f(pos.x - oldPosition.x, pos.y - oldPosition.y, pos.z - oldPosition.z);
 		oldPosition= pos;
 	}
 	ParticleSystem::update();
@@ -1323,13 +1323,13 @@ void UnitParticleSystem::loadGame(const XmlNode *rootNode) {
 //	float minRadius;
 	minRadius = unitParticleSystemNode->getAttribute("minRadius")->getFloatValue();
 //	Vec3f windSpeed;
-	windSpeed = Vec3d::strToVec3(unitParticleSystemNode->getAttribute("windSpeed")->getValue());
+	windSpeed = Vec3f::strToVec3(unitParticleSystemNode->getAttribute("windSpeed")->getValue());
 //	Vec3f cRotation;
-	windSpeed = Vec3d::strToVec3(unitParticleSystemNode->getAttribute("cRotation")->getValue());
+	windSpeed = Vec3f::strToVec3(unitParticleSystemNode->getAttribute("cRotation")->getValue());
 //	Vec3f fixedAddition;
-	fixedAddition = Vec3d::strToVec3(unitParticleSystemNode->getAttribute("fixedAddition")->getValue());
+	fixedAddition = Vec3f::strToVec3(unitParticleSystemNode->getAttribute("fixedAddition")->getValue());
 //    Vec3f oldPosition;
-	oldPosition = Vec3d::strToVec3(unitParticleSystemNode->getAttribute("oldPosition")->getValue());
+	oldPosition = Vec3f::strToVec3(unitParticleSystemNode->getAttribute("oldPosition")->getValue());
 //    bool energyUp;
 	energyUp = unitParticleSystemNode->getAttribute("energyUp")->getIntValue() != 0;
 //	float startTime;
@@ -1434,7 +1434,7 @@ RainParticleSystem::RainParticleSystem(int particleCount) :
 
 	setEmissionRate(25.0f);
 	setParticleSize(3.0f);
-	setColor(Vec4d(0.5f, 0.5f, 0.5f, 0.3f));
+	setColor(Vec4f(0.5f, 0.5f, 0.5f, 0.3f));
 	setSpeed(0.2f);
 }
 
@@ -1450,9 +1450,9 @@ void RainParticleSystem::initParticle(Particle *p, int particleIndex){
 
 	p->color= color;
 	p->energy= 10000;
-	p->pos= Vec3d(pos.x + x, pos.y, pos.z + y);
+	p->pos= Vec3f(pos.x + x, pos.y, pos.z + y);
 	p->lastPos= p->pos;
-	p->speed= Vec3d(random.randRange(-speed / 10, speed / 10), -speed, random.randRange(-speed / 10, speed / 10))
+	p->speed= Vec3f(random.randRange(-speed / 10, speed / 10), -speed, random.randRange(-speed / 10, speed / 10))
 	        + windSpeed;
 }
 
@@ -1504,7 +1504,7 @@ SnowParticleSystem::SnowParticleSystem(int particleCount) :
 
 	setEmissionRate(2.0f);
 	setParticleSize(0.2f);
-	setColor(Vec4d(0.8f, 0.8f, 0.8f, 0.8f));
+	setColor(Vec4f(0.8f, 0.8f, 0.8f, 0.8f));
 	setSpeed(0.05f);
 }
 
@@ -1517,9 +1517,9 @@ void SnowParticleSystem::initParticle(Particle *p, int particleIndex){
 
 	p->color= color;
 	p->energy= 10000;
-	p->pos= Vec3d(pos.x + x, pos.y, pos.z + y);
+	p->pos= Vec3f(pos.x + x, pos.y, pos.z + y);
 	p->lastPos= p->pos;
-	p->speed= Vec3d(0.0f, -speed, 0.0f) + windSpeed;
+	p->speed= Vec3f(0.0f, -speed, 0.0f) + windSpeed;
 	p->speed.x+= random.randRange(-0.005f, 0.005f);
 	p->speed.y+= random.randRange(-0.005f, 0.005f);
 }
@@ -1617,7 +1617,7 @@ string AttackParticleSystem::toString() const {
 ProjectileParticleSystem::ProjectileParticleSystem(int particleCount) :
 	AttackParticleSystem(particleCount){
 	setEmissionRate(20.0f);
-	setColor(Vec4d(1.0f, 0.3f, 0.0f, 0.5f));
+	setColor(Vec4f(1.0f, 0.3f, 0.0f, 0.5f));
 	setMaxParticleEnergy(100);
 	setVarParticleEnergy(50);
 	setParticleSize(0.4f);
@@ -1658,12 +1658,12 @@ void ProjectileParticleSystem::update(){
 		flatPos.y = truncateDecimal<double>(flatPos.y);
 		flatPos.z = truncateDecimal<double>(flatPos.z);
 
-		Vec3d targetVector = endPos - startPos;
+		Vec3f targetVector = endPos - startPos;
 		targetVector.x = truncateDecimal<double>(targetVector.x);
 		targetVector.y = truncateDecimal<double>(targetVector.y);
 		targetVector.z = truncateDecimal<double>(targetVector.z);
 
-		Vec3d currentVector = flatPos - startPos;
+		Vec3f currentVector = flatPos - startPos;
 		currentVector.x = truncateDecimal<double>(currentVector.x);
 		currentVector.y = truncateDecimal<double>(currentVector.y);
 		currentVector.z = truncateDecimal<double>(currentVector.z);
@@ -1775,9 +1775,9 @@ void ProjectileParticleSystem::initParticle(Particle *p, int particleIndex){
 
 	p->pos= pos + (lastPos - pos) * t;
 	p->lastPos= lastPos;
-	p->speed= Vec3d(random.randRange(-0.1f, 0.1f), random.randRange(-0.1f, 0.1f), random.randRange(-0.1f, 0.1f))
+	p->speed= Vec3f(random.randRange(-0.1f, 0.1f), random.randRange(-0.1f, 0.1f), random.randRange(-0.1f, 0.1f))
 	        * speed;
-	p->accel= Vec3d(0.0f, -gravity, 0.0f);
+	p->accel= Vec3f(0.0f, -gravity, 0.0f);
 
 	updateParticle(p);
 }
@@ -1794,12 +1794,12 @@ void ProjectileParticleSystem::updateParticle(Particle *p){
 	p->energy--;
 }
 
-void ProjectileParticleSystem::setPath(Vec3d startPos, Vec3d endPos){
+void ProjectileParticleSystem::setPath(Vec3f startPos, Vec3f endPos){
 
 	//compute axis
 	zVector= endPos - startPos;
 	zVector.normalize();
-	yVector= Vec3d(0.0f, 1.0f, 0.0f);
+	yVector= Vec3f(0.0f, 1.0f, 0.0f);
 	xVector= zVector.cross(yVector);
 
 	//apply offset
@@ -1814,7 +1814,7 @@ void ProjectileParticleSystem::setPath(Vec3d startPos, Vec3d endPos){
 	//recompute axis
 	zVector= endPos - startPos;
 	zVector.normalize();
-	yVector= Vec3d(0.0f, 1.0f, 0.0f);
+	yVector= Vec3f(0.0f, 1.0f, 0.0f);
 	xVector= zVector.cross(yVector);
 
 	// set members
@@ -1894,20 +1894,20 @@ void ProjectileParticleSystem::loadGame(const XmlNode *rootNode) {
 		nextParticleSystem->loadGame(splashParticleSystemNode);
 	}
 	//	Vec3f lastPos;
-	lastPos = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("lastPos")->getValue());
+	lastPos = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("lastPos")->getValue());
 	//	Vec3f startPos;
-	startPos = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("startPos")->getValue());
+	startPos = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("startPos")->getValue());
 	//	Vec3f endPos;
-	endPos = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("endPos")->getValue());
+	endPos = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("endPos")->getValue());
 	//	Vec3f flatPos;
-	flatPos = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("flatPos")->getValue());
+	flatPos = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("flatPos")->getValue());
 	//
 	//	Vec3f xVector;
-	xVector = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("xVector")->getValue());
+	xVector = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("xVector")->getValue());
 	//	Vec3f yVector;
-	yVector = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("yVector")->getValue());
+	yVector = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("yVector")->getValue());
 	//	Vec3f zVector;
-	zVector = Vec3d::strToVec3(projectileParticleSystemNode->getAttribute("zVector")->getValue());
+	zVector = Vec3f::strToVec3(projectileParticleSystemNode->getAttribute("zVector")->getValue());
 	//	Trajectory trajectory;
 	trajectory = static_cast<Trajectory>(projectileParticleSystemNode->getAttribute("trajectory")->getIntValue());
 	//	float trajectorySpeed;
@@ -1958,7 +1958,7 @@ string ProjectileParticleSystem::toString() const {
 
 SplashParticleSystem::SplashParticleSystem(int particleCount) :
 	AttackParticleSystem(particleCount){
-	setColor(Vec4d(1.0f, 0.3f, 0.0f, 0.8f));
+	setColor(Vec4f(1.0f, 0.3f, 0.0f, 0.8f));
 	setMaxParticleEnergy(100);
 	setVarParticleEnergy(50);
 	setParticleSize(1.0f);
@@ -2008,13 +2008,13 @@ void SplashParticleSystem::initParticle(Particle *p, int particleIndex){
 	p->size= particleSize;
 	p->color= color;
 
-	p->speed= Vec3d(horizontalSpreadA * random.randRange(-1.0f, 1.0f) + horizontalSpreadB, verticalSpreadA
+	p->speed= Vec3f(horizontalSpreadA * random.randRange(-1.0f, 1.0f) + horizontalSpreadB, verticalSpreadA
 	        * random.randRange(-1.0f, 1.0f) + verticalSpreadB, horizontalSpreadA * random.randRange(-1.0f, 1.0f)
 	        + horizontalSpreadB);
 	p->speed.normalize();
 	p->speed= p->speed * speed;
 
-	p->accel= Vec3d(0.0f, -gravity, 0.0f);
+	p->accel= Vec3f(0.0f, -gravity, 0.0f);
 }
 
 void SplashParticleSystem::updateParticle(Particle *p){