Review changes

Author: MaximDude

Managers/FrameMan.cpp

@@ -24,15 +24,15 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	/// <summary>
-	/// Callback function for the allegro set_display_switch_callback. It will be called when focus is switched away from the game window.
+	/// Callback function for the allegro set_display_switch_callback. It will be called when focus is switched away from the game window. 
+	/// It will temporarily disable positioning of the mouse so that when focus is switched back to the game window, the game window won't fly away because the user clicked the title bar of the window.
 	/// </summary>
 	void DisplaySwitchOut(void) { g_UInputMan.DisableMouseMoving(true); }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	/// <summary>
-	/// Callback function for the allegro set_display_switch_callback. It will be called when focus is switched back to the game window. It will temporarily disable positioning of the mouse.
-	/// This is so that when focus is switched back to the game window, it avoids having the window fly away because the user clicked the title bar of the window.
+	/// Callback function for the allegro set_display_switch_callback. It will be called when focus is switched back to the game window.
 	/// </summary>
 	void DisplaySwitchIn(void) { g_UInputMan.DisableMouseMoving(false); }
 
@@ -70,22 +70,22 @@ namespace RTE {
 		m_SmallFont = 0;
 		m_TextBlinkTimer.Reset();
 
-		for (short i = 0; i < c_MaxScreenCount; ++i) {
-			m_ScreenText[i].clear();
-			m_TextDuration[i] = -1;
-			m_TextDurationTimer[i].Reset();
-			m_TextBlinking[i] = 0;
-			m_TextCentered[i] = false;
-			m_FlashScreenColor[i] = -1;
-			m_FlashedLastFrame[i] = false;
-			m_FlashTimer[i].Reset();
-			m_NetworkBitmapIsLocked[i] = false;
-
-			for (short f = 0; f < 2; f++) {
-				m_NetworkBackBufferIntermediate8[f][i] = 0;
-				m_NetworkBackBufferFinal8[f][i] = 0;
-				m_NetworkBackBufferIntermediateGUI8[f][i] = 0;
-				m_NetworkBackBufferFinalGUI8[f][i] = 0;
+		for (short screenCount = 0; screenCount < c_MaxScreenCount; ++screenCount) {
+			m_ScreenText[screenCount].clear();
+			m_TextDuration[screenCount] = -1;
+			m_TextDurationTimer[screenCount].Reset();
+			m_TextBlinking[screenCount] = 0;
+			m_TextCentered[screenCount] = false;
+			m_FlashScreenColor[screenCount] = -1;
+			m_FlashedLastFrame[screenCount] = false;
+			m_FlashTimer[screenCount].Reset();
+			m_NetworkBitmapIsLocked[screenCount] = false;
+
+			for (short bufferFrame = 0; bufferFrame < 2; bufferFrame++) {
+				m_NetworkBackBufferIntermediate8[bufferFrame][screenCount] = 0;
+				m_NetworkBackBufferFinal8[bufferFrame][screenCount] = 0;
+				m_NetworkBackBufferIntermediateGUI8[bufferFrame][screenCount] = 0;
+				m_NetworkBackBufferFinalGUI8[bufferFrame][screenCount] = 0;
 			}
 		}
 	}
@@ -150,7 +150,6 @@ namespace RTE {
 
 		// Set the switching mode; what happens when the app window is switched to and from
 		set_display_switch_mode(SWITCH_BACKGROUND);
-		//set_display_switch_mode(SWITCH_PAUSE);
 		set_display_switch_callback(SWITCH_OUT, DisplaySwitchOut);
 		set_display_switch_callback(SWITCH_IN, DisplaySwitchIn);
 
@@ -163,6 +162,14 @@ namespace RTE {
 		// Set the one Allegro currently uses
 		color_map = &m_HalfTransTable;
 
+		CreateBackBuffers();
+
+		return 0;
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	int FrameMan::CreateBackBuffers() {
 		// Create the back buffer, this is still in 8bpp, we will do any post-processing on the PostProcessing bitmap
 		m_BackBuffer8 = create_bitmap_ex(8, m_ResX, m_ResY);
 		ClearBackBuffer8();
@@ -280,7 +287,6 @@ namespace RTE {
 		delete m_LargeFont;
 		delete m_SmallFont;
 
-		g_TimerMan.Destroy();
 		Clear();
 	}
 
@@ -340,9 +346,9 @@ namespace RTE {
 			// Make sure everything gets caught up after the switch
 			rest(2000);
 			g_ConsoleMan.PrintString("SYSTEM: Switched to windowed mode");
-			m_Fullscreen = false;
-			// Switch to fullscreen
+			m_Fullscreen = false;			
 		} else {
+			// Switch to fullscreen
 			if (set_gfx_mode(fullscreenGfxDriver, resX * m_NxFullscreen, resY * m_NxFullscreen, 0, 0) != 0) {
 				// Oops, failed to set fullscreen mode, try a different fullscreen scaling
 				m_NewNxFullscreen = m_NxFullscreen = m_NxFullscreen == 1 ? 2 : 1;
@@ -453,7 +459,6 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void FrameMan::ResetSplitScreens(bool hSplit, bool vSplit) {
-		// Free the previous splitscreen, if any
 		if (m_PlayerScreen) { release_bitmap(m_PlayerScreen); }
 
 		// Override screen splitting according to settings if needed
@@ -470,16 +475,13 @@ namespace RTE {
 			clear_to_color(m_PlayerScreen, m_BlackColor);
 			set_clip_state(m_PlayerScreen, 1);
 
-			// Update these to represent the split screens
 			m_PlayerScreenWidth = m_PlayerScreen->w;
 			m_PlayerScreenHeight = m_PlayerScreen->h;
-
-		// No splits, so set the screen dimensions equal to the back buffer
 		} else {
+			// No splits, so set the screen dimensions equal to the back buffer
 			m_PlayerScreenWidth = m_BackBuffer8->w;
 			m_PlayerScreenHeight = m_BackBuffer8->h;
 		}
-		// Reset the flashes
 		for (short i = 0; i < c_MaxScreenCount; ++i) {
 			m_FlashScreenColor[i] = -1;
 			m_FlashedLastFrame[i] = false;
@@ -588,7 +590,7 @@ namespace RTE {
 				color_map = &m_HalfTransTable;
 				break;
 			default:
-				RTEAbort("Undefined transparency preset value passed in. See TransparencyPreset enumeration for defined values.")
+				RTEAbort("Undefined transparency preset value passed in. See TransparencyPreset enumeration for defined values.");
 		}
 	}
 

Managers/FrameMan.h

@@ -21,7 +21,7 @@ namespace RTE {
 
 	public:
 
-		Vector SLOffset[c_MaxScreenCount][c_MaxLayersStoredForNetwork]; //!<
+		Vector SLOffset[c_MaxScreenCount][c_MaxLayersStoredForNetwork]; //!< SceneLayer offsets for each screen in online multiplayer.
 
 #pragma region Creation
 		/// <summary>
@@ -276,17 +276,17 @@ namespace RTE {
 		int GetPlayerScreenHeight() const { return GetPlayerFrameBufferHeight(-1); }
 
 		/// <summary>
-		/// Gets the width of the individual player screens. This will only be less than the backbuffer resolution if there are split screens.
+		/// Gets the width of the specified player screen. This will only be less than the backbuffer resolution if there are split screens.
 		/// </summary>
 		/// <param name="whichPlayer">Player to get screen width for, only used by multiplayer parts.</param>
-		/// <returns>The width of the player screens.</returns>
+		/// <returns>The width of the specified player screen.</returns>
 		int GetPlayerFrameBufferWidth(int whichPlayer) const;
 
 		/// <summary>
-		/// Gets the height of the individual player screens. This will only be less than the backbuffer resolution if there are split screens.
+		/// Gets the height of the specified player screen. This will only be less than the backbuffer resolution if there are split screens.
 		/// </summary>
 		/// <param name="whichPlayer">Player to get screen width for, only used by multiplayer parts.</param>
-		/// <returns>The height of the player screens.</returns>
+		/// <returns>The height of the specified player screen.</returns>
 		int GetPlayerFrameBufferHeight(int whichPlayer) const;
 #pragma endregion
 
@@ -591,14 +591,14 @@ namespace RTE {
 		int m_NewResY; //!< New display height that will take effect next time the FrameMan is started.
 
 		bool m_Fullscreen; //!< Whether in fullscreen mode or not.	
-		int m_NxWindowed; //!< The number of times the windowed mode resolution should be multiplied and stretched across for better visibility.
 
 		/// <summary>
 		/// The number of times the fullscreen mode resolution should be multiplied and stretched across for better visibility.
 		/// The internal virtual resolution (m_ResX, m_ResY) is 1/n of the actual fullscreen resolution that the graphics card outputs.
 		/// </summary>
 		int m_NxFullscreen;
 		int m_NewNxFullscreen; //!< This is the new fullscreen multiple that will take effect next time the FrameMan is started.
+		int m_NxWindowed; //!< The number of times the windowed mode resolution should be multiplied and stretched across for better visibility.
 
 		bool m_HSplit; //!< Whether the screen is split horizontally across the screen, ie as two splitscreens one above the other.		
 		bool m_VSplit; //!< Whether the screen is split vertically across the screen, ie as two splitscreens side by side.	
@@ -660,6 +660,15 @@ namespace RTE {
 		//std::mutex m_NetworkBitmapIsLocked[c_MaxScreenCount];
 
 	private:
+
+#pragma region Create Breakdown
+		/// <summary>
+		/// Creates all the frame buffer bitmaps to be used by FrameMan. This is called during Create().
+		/// </summary>
+		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
+		int CreateBackBuffers();
+#pragma endregion
+
 #pragma region Draw Breakdown
 		/// <summary>
 		/// Draws all the text messages to the specified player screen. This is called during Draw().

Managers/PerformanceMan.h

@@ -179,11 +179,6 @@ namespace RTE {
 	private:
 
 #pragma region Performance Counter Handling
-		/// <summary>
-		/// Draws the performance graphs to the screen. This will be called by Draw() if advanced performance stats are enabled.
-		/// </summary>
-		void DrawPeformanceGraphs(AllegroBitmap bitmapToDrawTo);
-
 		/// <summary>
 		/// Adds provided value to current sample of specified performance counter.
 		/// </summary>
@@ -204,6 +199,11 @@ namespace RTE {
 		unsigned long long GetPerformanceCounterAverage(PerformanceCounters counter);
 #pragma endregion
 
+		/// <summary>
+		/// Draws the performance graphs to the screen. This will be called by Draw() if advanced performance stats are enabled.
+		/// </summary>
+		void DrawPeformanceGraphs(AllegroBitmap bitmapToDrawTo);
+
 		/// <summary>
 		/// Clears all the member variables of this PerformanceMan, effectively resetting the members of this abstraction level only.
 		/// </summary>

Managers/PostProcessMan.cpp

@@ -83,7 +83,6 @@ namespace RTE {
 		int right = left + boxWidth;
 		int bottom = top + boxHeight;
 
-		// Check wrapped rectangles
 		if (g_SceneMan.SceneWrapsX()) {
 			int sceneWidth = g_SceneMan.GetScene()->GetWidth();
 			if (left < 0) { found = GetPostScreenEffects(left + sceneWidth, top, right + sceneWidth, bottom, effectsList, team) || found; }
@@ -370,13 +369,10 @@ namespace RTE {
 
 					clear_to_color(pTargetBitmap, 0);
 
-					//fixed fAngle;
-					//fAngle = fixmul(angle, radtofix_r);
+					Matrix newAngle;
+					newAngle.SetRadAngle(angle);
 
-					Matrix m;
-					m.SetRadAngle(angle);
-
-					rotate_sprite(pTargetBitmap, pBitmap, 0, 0, ftofix(m.GetAllegroAngle()));
+					rotate_sprite(pTargetBitmap, pBitmap, 0, 0, ftofix(newAngle.GetAllegroAngle()));
 					draw_trans_sprite(g_FrameMan.GetBackBuffer32(), pTargetBitmap, effectPosX, effectPosY);
 				}
 			}

Managers/PostProcessMan.h

@@ -88,9 +88,9 @@ namespace RTE {
 
 #pragma region Post Effect Handling
 		/// <summary>
-		/// 
+		/// Gets the list of effects to apply at the end of each frame.
 		/// </summary>
-		/// <returns></returns>
+		/// <returns>The list of effects to apply at the end of each frame.</returns>
 		std::list<PostEffect> *GetPostScreenEffectsList() { return &m_PostScreenEffects; }
 
 		/// <summary>
@@ -116,18 +116,18 @@ namespace RTE {
 		bool GetPostScreenEffectsWrapped(const Vector &boxPos, int boxWidth, int boxHeight, std::list<PostEffect> &effectsList, int team = -1);
 
 		/// <summary>
-		/// 
+		/// Gets a temporary bitmap of specified size to rotate post effects in.
 		/// </summary>
-		/// <param name="bitmapSize"></param>
-		/// <returns></returns>
+		/// <param name="bitmapSize">Size of bitmap to get.</param>
+		/// <returns>Pointer to the temporary bitmap.</returns>
 		BITMAP* GetTempEffectBitmap(unsigned short bitmapSize) const;
 #pragma endregion
 
 #pragma region Post Pixel Glow Handling
 		/// <summary>
-		/// 
+		/// Gets the list of areas that will be processed with glow.
 		/// </summary>
-		/// <returns></returns>
+		/// <returns>The list of areas that will be processed with glow.</returns>
 		std::list<Box>* GetPostScreenGlowBoxesList() { return &m_PostScreenGlowBoxes; }
 
 		/// <summary>
@@ -137,7 +137,7 @@ namespace RTE {
 		void RegisterGlowArea(const IntRect &glowArea) { if (g_TimerMan.DrawnSimUpdate() && g_TimerMan.SimUpdatesSinceDrawn() >= 0) { m_GlowAreas.push_back(glowArea); } }
 
 		/// <summary>
-		/// Registers a specific IntRect to be post-processed and have special pixel colors lit up by glow effects in it.
+		/// Creates an IntRect and registers it to be post-processed and have special pixel colors lit up by glow effects in it.
 		/// </summary>
 		/// <param name="center">The center of the IntRect.</param>
 		/// <param name="radius">The radius around it to add as an area.</param>
@@ -164,17 +164,19 @@ namespace RTE {
 #pragma endregion
 
 #pragma region Network Post Effect Handling
+		// TODO: Figure out.
 		/// <summary>
 		/// 
 		/// </summary>
-		/// <param name="whichScreen"></param>
+		/// <param name="whichScreen">Which player screen to get list for.</param>
 		/// <param name="outputList"></param>
 		void GetNetworkPostEffectsList(int whichScreen, std::list<PostEffect> & outputList);
 
+		// TODO: Figure out.
 		/// <summary>
 		/// 
 		/// </summary>
-		/// <param name="whichScreen"></param>
+		/// <param name="whichScreen">Which player screen to set list for.</param>
 		/// <param name="inputList"></param>
 		void SetNetworkPostEffectsList(int whichScreen, std::list<PostEffect> & inputList);
 #pragma endregion
@@ -194,11 +196,11 @@ namespace RTE {
 		std::list<PostEffect> m_PostScreenEffects; //!< List of effects to apply at the end of each frame. This list gets cleared out and re-filled each frame.
 		std::list<PostEffect> m_PostSceneEffects; //!< All post-processing effects registered for this draw frame in the scene.
 
-		std::list<Box> m_PostScreenGlowBoxes; //!< List of screen-relative areas that will be processed with glow.
+		std::list<Box> m_PostScreenGlowBoxes; //!< List of areas that will be processed with glow.
 		std::list<IntRect> m_GlowAreas; //!< All the areas to do post glow pixel effects on, in scene coordinates.
 
-		std::list<PostEffect> m_ScreenRelativeEffects[c_MaxScreenCount]; //!<
-		std::mutex ScreenRelativeEffectsMutex[c_MaxScreenCount]; //!<
+		std::list<PostEffect> m_ScreenRelativeEffects[c_MaxScreenCount]; //!< List of screen relative effects for each player in online multiplayer.
+		std::mutex ScreenRelativeEffectsMutex[c_MaxScreenCount]; //!< Mutex for the ScreenRelativeEffects list when accessed by multiple threads in online multiplayer.
 
 		BITMAP *m_YellowGlow; //!< Bitmap for the yellow dot glow effect.
 		BITMAP *m_RedGlow; //!< Bitmap for the red dot glow effect.
@@ -260,12 +262,12 @@ namespace RTE {
 
 #pragma region PostProcess Breakdown
 		/// <summary>
-		/// 
+		/// Draws all the glow dot effects on pixels registered inside glow boxes for this frame. This is called from PostProcess().
 		/// </summary>
 		void DrawDotGlowEffects();
 
 		/// <summary>
-		/// 
+		/// Draws all the glow effects registered for this frame. This is called from PostProcess().
 		/// </summary>
 		void DrawPostScreenEffects();
 #pragma endregion