Add TempScale enum

src/Format.cpp

@@ -339,14 +339,14 @@ ByteString format::URLDecode(ByteString source)
 	return result;
 }
 
-void format::RenderTemperature(StringBuilder &sb, float temp, int scale)
+void format::RenderTemperature(StringBuilder &sb, float temp, TempScale scale)
 {
 	switch (scale)
 	{
-	case 1:
+	case TEMPSCALE_CELSIUS:
 		sb << (temp - 273.15f) << "C";
 		break;
-	case 2:
+	case TEMPSCALE_FAHRENHEIT:
 		sb << (temp - 273.15f) * 1.8f + 32.0f << "F";
 		break;
 	default:
@@ -355,24 +355,24 @@ void format::RenderTemperature(StringBuilder &sb, float temp, int scale)
 	}
 }
 
-float format::StringToTemperature(String str, int defaultScale)
+float format::StringToTemperature(String str, TempScale defaultScale)
 {
 	auto scale = defaultScale;
 	if (str.size())
 	{
 		if (str.EndsWith("K"))
 		{
-			scale = 0;
+			scale = TEMPSCALE_KELVIN;
 			str = str.SubstrFromEnd(1);
 		}
 		else if (str.EndsWith("C"))
 		{
-			scale = 1;
+			scale = TEMPSCALE_CELSIUS;
 			str = str.SubstrFromEnd(1);
 		}
 		else if (str.EndsWith("F"))
 		{
-			scale = 2;
+			scale = TEMPSCALE_FAHRENHEIT;
 			str = str.SubstrFromEnd(1);
 		}
 	}
@@ -383,12 +383,14 @@ float format::StringToTemperature(String str, int defaultScale)
 	auto out = str.ToNumber<float>();
 	switch (scale)
 	{
-	case 1:
+	case TEMPSCALE_CELSIUS:
 		out = out + 273.15;
 		break;
-	case 2:
+	case TEMPSCALE_FAHRENHEIT:
 		out = (out - 32.0f) / 1.8f + 273.15f;
 		break;
+	default:
+		break;
 	}
 	return out;
 }

src/Format.h

@@ -5,6 +5,7 @@
 #include "common/String.h"
 #include "common/Plane.h"
 #include "graphics/Pixel.h"
+#include "simulation/SimulationSettings.h"
 
 class VideoBuffer;
 
@@ -19,6 +20,6 @@ namespace format
 	std::unique_ptr<std::vector<char>> PixelsToPNG(PlaneAdapter<std::vector<pixel>> const &);
 	std::unique_ptr<PlaneAdapter<std::vector<pixel_rgba>>> PixelsFromPNG(std::span<const char> data);
 	std::unique_ptr<PlaneAdapter<std::vector<pixel>>> PixelsFromPNG(std::span<const char> data, RGB background);
-	void RenderTemperature(StringBuilder &sb, float temp, int scale);
-	float StringToTemperature(String str, int defaultScale);
+	void RenderTemperature(StringBuilder &sb, float temp, TempScale scale);
+	float StringToTemperature(String str, TempScale defaultScale);
 }

src/gui/game/GameController.cpp

@@ -1033,12 +1033,12 @@ bool GameController::GetDebugHUD()
 	return gameView->GetDebugHUD();
 }
 
-void GameController::SetTemperatureScale(int temperatureScale)
+void GameController::SetTemperatureScale(TempScale temperatureScale)
 {
 	gameModel->SetTemperatureScale(temperatureScale);
 }
 
-int GameController::GetTemperatureScale()
+TempScale GameController::GetTemperatureScale()
 {
 	return gameModel->GetTemperatureScale();
 }

src/gui/game/GameController.h

@@ -8,6 +8,7 @@
 #include "gui/SavePreviewType.h"
 #include "simulation/Sign.h"
 #include "simulation/Particle.h"
+#include "simulation/SimulationSettings.h"
 #include "Misc.h"
 #include <vector>
 #include <utility>
@@ -129,8 +130,8 @@ public:
 	bool GetBrushEnable();
 	void SetDebugHUD(bool hudState);
 	bool GetDebugHUD();
-	void SetTemperatureScale(int temperatureScale);
-	int GetTemperatureScale();
+	void SetTemperatureScale(TempScale temperatureScale);
+	TempScale GetTemperatureScale();
 	int GetEdgeMode();
 	void SetEdgeMode(int edgeMode);
 	void SetDebugFlags(unsigned int flags) { debugFlags = flags; }

src/gui/game/GameModel.cpp

@@ -167,7 +167,7 @@ GameModel::GameModel(GameView *newView):
 
 	mouseClickRequired = prefs.Get("MouseClickRequired", false);
 	includePressure = prefs.Get("Simulation.IncludePressure", true);
-	temperatureScale = prefs.Get("Renderer.TemperatureScale", 1); // TODO: TemperatureScale enum
+	temperatureScale = prefs.Get("Renderer.TemperatureScale", NUM_TEMPSCALES, TEMPSCALE_CELSIUS);
 
 	ClearSimulation();
 }
@@ -287,7 +287,7 @@ int GameModel::GetEdgeMode()
 	return this->edgeMode;
 }
 
-void GameModel::SetTemperatureScale(int temperatureScale)
+void GameModel::SetTemperatureScale(TempScale temperatureScale)
 {
 	this->temperatureScale = temperatureScale;
 }

src/gui/game/GameModel.h

@@ -4,6 +4,7 @@
 #include "gui/interface/Point.h"
 #include "graphics/RendererSettings.h"
 #include "simulation/CustomGOLData.h"
+#include "simulation/SimulationSettings.h"
 #include <vector>
 #include <deque>
 #include <memory>
@@ -95,7 +96,7 @@ private:
 	bool mouseClickRequired;
 	bool includePressure;
 	bool perfectCircle = true;
-	int temperatureScale;
+	TempScale temperatureScale;
 
 	size_t activeColourPreset;
 	std::vector<ui::Colour> colourPresets;
@@ -150,8 +151,8 @@ public:
 
 	void SetEdgeMode(int edgeMode);
 	int GetEdgeMode();
-	void SetTemperatureScale(int temperatureScale);
-	inline int GetTemperatureScale() const
+	void SetTemperatureScale(TempScale temperatureScale);
+	inline TempScale GetTemperatureScale() const
 	{
 		return temperatureScale;
 	}

src/gui/options/OptionsController.cpp

@@ -67,7 +67,7 @@ void OptionsController::SetEdgeMode(int edgeMode)
 	model->SetEdgeMode(edgeMode);
 }
 
-void OptionsController::SetTemperatureScale(int temperatureScale)
+void OptionsController::SetTemperatureScale(TempScale temperatureScale)
 {
 	model->SetTemperatureScale(temperatureScale);
 }

src/gui/options/OptionsController.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <functional>
+#include "simulation/SimulationSettings.h"
 
 class GameModel;
 class OptionsModel;
@@ -23,7 +24,7 @@ public:
 	void SetAirMode(int airMode);
 	void SetAmbientAirTemperature(float ambientAirTemp);
 	void SetEdgeMode(int edgeMode);
-	void SetTemperatureScale(int temperatureScale);
+	void SetTemperatureScale(TempScale temperatureScale);
 	void SetThreadedRendering(bool newThreadedRendering);
 	void SetFullscreen(bool fullscreen);
 	void SetChangeResolution(bool newChangeResolution);

src/gui/options/OptionsModel.cpp

@@ -85,13 +85,13 @@ void OptionsModel::SetEdgeMode(int edgeMode)
 	notifySettingsChanged();
 }
 
-int OptionsModel::GetTemperatureScale()
+TempScale OptionsModel::GetTemperatureScale()
 {
 	return gModel->GetTemperatureScale();
 }
-void OptionsModel::SetTemperatureScale(int temperatureScale)
+void OptionsModel::SetTemperatureScale(TempScale temperatureScale)
 {
-	GlobalPrefs::Ref().Set("Renderer.TemperatureScale", temperatureScale);
+	GlobalPrefs::Ref().Set("Renderer.TemperatureScale", int(temperatureScale));
 	gModel->SetTemperatureScale(temperatureScale);
 	notifySettingsChanged();
 }

src/gui/options/OptionsModel.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <vector>
+#include "simulation/SimulationSettings.h"
 
 class GameModel;
 class Simulation;
@@ -29,8 +30,8 @@ public:
 	void SetAmbientAirTemperature(float ambientAirTemp);
 	int GetEdgeMode();
 	void SetEdgeMode(int edgeMode);
-	int GetTemperatureScale();
-	void SetTemperatureScale(int temperatureScale);
+	TempScale GetTemperatureScale();
+	void SetTemperatureScale(TempScale temperatureScale);
 	int GetThreadedRendering();
 	void SetThreadedRendering(bool newThreadedRendering);
 	int GetGravityMode();

src/gui/options/OptionsView.cpp

@@ -222,11 +222,11 @@ OptionsView::OptionsView() : ui::Window(ui::Point(-1, -1), ui::Point(320, 340))
 		c->SetEdgeMode(edgeMode->GetOption().second);
 	});
 	temperatureScale = addDropDown("Temperature scale", {
-		{ "Kelvin", 0 },
-		{ "Celsius", 1 },
-		{ "Fahrenheit", 2 },
+		{ "Kelvin", TEMPSCALE_KELVIN },
+		{ "Celsius", TEMPSCALE_CELSIUS },
+		{ "Fahrenheit", TEMPSCALE_FAHRENHEIT },
 	}, [this] {
-		c->SetTemperatureScale(temperatureScale->GetOption().second);
+		c->SetTemperatureScale(TempScale(temperatureScale->GetOption().second));
 	});
 	if (FORCE_WINDOW_FRAME_OPS != forceWindowFrameOpsHandheld)
 	{
@@ -426,7 +426,7 @@ void OptionsView::AmbientAirTempToTextBox(float airTemp)
 {
 	StringBuilder sb;
 	sb << Format::Precision(2);
-	format::RenderTemperature(sb, airTemp, temperatureScale->GetOption().second);
+	format::RenderTemperature(sb, airTemp, TempScale(temperatureScale->GetOption().second));
 	ambientAirTemp->SetText(sb.Build());
 }
 
@@ -466,7 +466,7 @@ void OptionsView::UpdateAirTemp(String temp, bool isDefocus)
 	bool isValid;
 	try
 	{
-		airTemp = format::StringToTemperature(temp, temperatureScale->GetOption().second);
+		airTemp = format::StringToTemperature(temp, TempScale(temperatureScale->GetOption().second));
 		isValid = true;
 	}
 	catch (const std::exception &ex)

src/lua/LuaSimulation.cpp

@@ -1701,13 +1701,13 @@ static int temperatureScale(lua_State *L)
 	lsi->AssertInterfaceEvent();
 	if (lua_gettop(L) == 0)
 	{
-		lua_pushinteger(L, lsi->gameModel->GetTemperatureScale());
+		lua_pushinteger(L, int(lsi->gameModel->GetTemperatureScale()));
 		return 1;
 	}
 	int temperatureScale = luaL_checkinteger(L, 1);
-	if (temperatureScale < 0 || temperatureScale > 2)
+	if (temperatureScale < 0 || temperatureScale >= NUM_TEMPSCALES)
 		return luaL_error(L, "Invalid temperature scale");
-	lsi->gameModel->SetTemperatureScale(temperatureScale);
+	lsi->gameModel->SetTemperatureScale(TempScale(temperatureScale));
 	return 0;
 }
 
@@ -2129,6 +2129,11 @@ void LuaSimulation::Open(lua_State *L)
 	LCONST(DECOSPACE_GAMMA18);
 	LCONST(NUM_DECOSPACES);
 
+	LCONST(TEMPSCALE_KELVIN);
+	LCONST(TEMPSCALE_CELSIUS);
+	LCONST(TEMPSCALE_FAHRENHEIT);
+	LCONST(NUM_TEMPSCALES);
+
 	LCONSTAS("CANMOVE_BOUNCE", 0);
 	LCONSTAS("CANMOVE_SWAP", 1);
 	LCONSTAS("CANMOVE_ENTER", 2);

src/simulation/SimulationSettings.h

@@ -35,3 +35,11 @@ enum DecoSpace
 	DECOSPACE_GAMMA18,
 	NUM_DECOSPACES,
 };
+
+enum TempScale
+{
+	TEMPSCALE_KELVIN,
+	TEMPSCALE_CELSIUS,
+	TEMPSCALE_FAHRENHEIT,
+	NUM_TEMPSCALES,
+};