cleanup and documentation

Author: HeliumAnt

Source/Entities/MOSParticle.cpp

@@ -203,12 +203,9 @@ void MOSParticle::Draw(BITMAP* targetBitmap, const Vector& targetPos, DrawMode m
 				break;
 			case g_DrawTrans:
 				DrawTexture(m_aSprite[m_Frame], spriteX, spriteY, {255, 255, 255, g_FrameMan.GetCurrentAlpha()});
-				// draw_trans_sprite(targetBitmap, m_aSprite[m_Frame], spriteX, spriteY);
 				break;
 			case g_DrawAlpha:
 				DrawTexture(m_aSprite[m_Frame], spriteX, spriteY, {255, 255, 255, 255});
-				// set_alpha_blender();
-				// draw_trans_sprite(targetBitmap, m_aSprite[m_Frame], spriteX, spriteY);
 				break;
 			case g_DrawMOID:
 				break;

Source/Entities/MOSRotating.cpp

@@ -1669,13 +1669,6 @@ void MOSRotating::Draw(BITMAP* pTargetBitmap, const Vector& targetPos, DrawMode
 		}
 
 		if (mode == g_DrawTrans) {
-			clear_to_color(pTempBitmap, keyColor);
-
-			// Draw the rotated thing onto the intermediate bitmap so its COM position aligns with the middle of the temp bitmap.
-			// The temp bitmap should be able to hold the full size since it is larger than the max diameter.
-			// Take into account the h-flipped pivot point
-			pivot_scaled_sprite(pTempBitmap, pFlipBitmap, pTempBitmap->w / 2, pTempBitmap->h / 2, pFlipBitmap->w + m_SpriteOffset.m_X, -(m_SpriteOffset.m_Y), ftofix(m_Rotation.GetAllegroAngle()), ftofix(m_Scale));
-
 			// Draw the now rotated object's temporary bitmap onto the final drawing bitmap with transperency
 			// Do the passes loop in here so the intermediate drawing doesn't get done multiple times
 			for (int i = 0; i < passes; ++i) {
@@ -1686,7 +1679,6 @@ void MOSRotating::Draw(BITMAP* pTargetBitmap, const Vector& targetPos, DrawMode
 					{aDrawPos[i].m_X, aDrawPos[i].m_Y, static_cast<float>(m_aSprite[m_Frame]->w), static_cast<float>(m_aSprite[m_Frame]->h)},
 					{m_aSprite[m_Frame]->w + m_SpriteOffset.m_X , -m_SpriteOffset.m_Y}, m_Rotation.GetRadAngle(), {255, 255, 255, g_FrameMan.GetCurrentAlpha()});
 				g_SceneMan.RegisterDrawing(pTargetBitmap, g_NoMOID, spriteX, spriteY, spriteX + pTempBitmap->w, spriteY + pTempBitmap->h);
-				//draw_trans_sprite(pTargetBitmap, pTempBitmap, spriteX, spriteY);
 			}
 		} else {
 			// Do the passes loop in here so the flipping operation doesn't get done multiple times
@@ -1704,13 +1696,6 @@ void MOSRotating::Draw(BITMAP* pTargetBitmap, const Vector& targetPos, DrawMode
 		}
 	} else {
 		if (mode == g_DrawTrans) {
-			clear_to_color(pTempBitmap, keyColor);
-
-			// Draw the rotated thing onto the intermediate bitmap so its COM position aligns with the middle of the temp bitmap.
-			// The temp bitmap should be able to hold the full size since it is larger than the max diameter.
-			// Take into account the h-flipped pivot point
-			pivot_scaled_sprite(pTempBitmap, m_aSprite[m_Frame], pTempBitmap->w / 2, pTempBitmap->h / 2, -m_SpriteOffset.GetFloorIntX(), -m_SpriteOffset.GetFloorIntY(), ftofix(m_Rotation.GetAllegroAngle()), ftofix(m_Scale));
-
 			// Draw the now rotated object's temporary bitmap onto the final drawing bitmap with transperency
 			// Do the passes loop in here so the intermediate drawing doesn't get done multiple times
 			for (int i = 0; i < passes; ++i) {
@@ -1721,7 +1706,6 @@ void MOSRotating::Draw(BITMAP* pTargetBitmap, const Vector& targetPos, DrawMode
 				int spriteX = aDrawPos[i].GetFloorIntX() - (pTempBitmap->w / 2);
 				int spriteY = aDrawPos[i].GetFloorIntY() - (pTempBitmap->h / 2);
 				g_SceneMan.RegisterDrawing(pTargetBitmap, g_NoMOID, spriteX, spriteY, spriteX + pTempBitmap->w, spriteY + pTempBitmap->h);
-				// draw_trans_sprite(pTargetBitmap, pTempBitmap, spriteX, spriteY);
 			}
 		} else {
 			for (int i = 0; i < passes; ++i) {

Source/Entities/PieMenu.cpp

@@ -638,11 +638,9 @@ void PieMenu::Draw(BITMAP* targetBitmap, const Vector& targetPos) const {
 	if (m_EnabledState != EnabledState::Disabled) {
 		if (m_DrawBackgroundTransparent && !g_FrameMan.IsInMultiplayerMode()) {
 			g_FrameMan.SetTransTableFromPreset(TransparencyPreset::MoreTrans);
-			//draw_trans_sprite(targetBitmap, m_BGBitmap, drawPos.GetFloorIntX() - m_BGBitmap->w / 2, drawPos.GetFloorIntY() - m_BGBitmap->h / 2);
 			g_GLResourceMan.UpdateDynamicBitmap(m_BGBitmap, true);
 			DrawTexture(g_GLResourceMan.GetStaticTextureFromBitmap(m_BGBitmap), drawPos.GetFloorIntX() - m_BGBitmap->w / 2, drawPos.GetFloorIntY() - m_BGBitmap->h / 2, {255, 255, 255, g_FrameMan.GetCurrentAlpha()});
 		} else {
-			//draw_sprite(targetBitmap, m_BGBitmap, drawPos.GetFloorIntX() - m_BGBitmap->w / 2, drawPos.GetFloorIntY() - m_BGBitmap->h / 2);
 			g_GLResourceMan.UpdateDynamicBitmap(m_BGBitmap, true);
 			DrawTexture(g_GLResourceMan.GetStaticTextureFromBitmap(m_BGBitmap), drawPos.GetFloorIntX() - m_BGBitmap->w / 2, drawPos.GetFloorIntY() - m_BGBitmap->h / 2, {255, 255, 255, 255});
 		}
@@ -959,59 +957,6 @@ void PieMenu::CalculateDrawPosition(const BITMAP* targetBitmap, const Vector& ta
 	}
 }
 
-void PieMenu::DrawMenuBackground() {
-	int centerX = IsSubPieMenu() ? 0 : m_BGBitmap->w / 2;
-	int centerY = IsSubPieMenu() ? 0 : m_BGBitmap->h / 2;
-	if (m_DirectionIfSubPieMenu == Directions::Up || m_DirectionIfSubPieMenu == Directions::Left) {
-		centerX = m_BGBitmap->w;
-	}
-	if (m_DirectionIfSubPieMenu == Directions::Up || m_DirectionIfSubPieMenu == Directions::Right) {
-		centerY = m_BGBitmap->h;
-	}
-	if (m_DirectionIfSubPieMenu == Directions::Down) {
-		centerX = -2;
-		centerY = -2;
-	}
-	if (m_DirectionIfSubPieMenu == Directions::Left) {
-		centerY = -2;
-	}
-	float subPieMenuRotationOffset = IsSubPieMenu() ? c_QuarterPI : 0;
-
-	bool pieMenuNeedsToBeDrawnRotated = GetRotAngle() - subPieMenuRotationOffset != 0;
-	BITMAP* bitmapToDrawTo = pieMenuNeedsToBeDrawnRotated ? m_BGRotationBitmap : m_BGBitmap;
-
-	bool hasPieSliceWithSubPieMenu = false;
-	for (const PieSlice* pieSlice: m_CurrentPieSlices) {
-		if (pieSlice->GetSubPieMenu()) {
-			hasPieSliceWithSubPieMenu = true;
-			break;
-		}
-	}
-
-	DrawRing(Vector2(centerX, centerY), m_CurrentInnerRadius, m_CurrentInnerRadius + m_BackgroundThickness, 0, 2*PI, 36, {255, 255, 255, 75});
-
-	if (m_EnabledState == EnabledState::Enabled) {
-		if (hasPieSliceWithSubPieMenu) {
-			clear_to_color(m_BGPieSlicesWithSubPieMenuBitmap, ColorKeys::g_MaskColor);
-			circlefill(m_BGPieSlicesWithSubPieMenuBitmap, centerX, centerY, m_CurrentInnerRadius + m_BackgroundThickness + c_PieSliceWithSubPieMenuExtraThickness, m_BackgroundColor);
-		}
-		DrawBackgroundPieSliceSeparators(bitmapToDrawTo, centerX, centerY, subPieMenuRotationOffset);
-		if (hasPieSliceWithSubPieMenu) {
-			circlefill(m_BGPieSlicesWithSubPieMenuBitmap, centerX, centerY, m_CurrentInnerRadius + m_BackgroundThickness, ColorKeys::g_MaskColor);
-			draw_sprite(m_BGPieSlicesWithSubPieMenuBitmap, bitmapToDrawTo, 0, 0);
-			clear_to_color(bitmapToDrawTo, ColorKeys::g_MaskColor);
-			draw_sprite(bitmapToDrawTo, m_BGPieSlicesWithSubPieMenuBitmap, 0, 0);
-		}
-	}
-
-	if (bitmapToDrawTo != m_BGBitmap) {
-		clear_to_color(m_BGBitmap, ColorKeys::g_MaskColor);
-		float rotationAsAllegroAngle = ((GetRotAngle() - subPieMenuRotationOffset) / c_PI) * -128.0F;
-		pivot_sprite(m_BGBitmap, bitmapToDrawTo, m_BGBitmap->w / 2, m_BGBitmap->h / 2, centerX, centerY, ftofix(rotationAsAllegroAngle));
-	}
-	m_BGBitmapNeedsRedrawing = false;
-	m_BGPieSlicesWithSubPieMenuBitmapNeedsRedrawing = false;
-}
 void PieMenu::DrawPieIcons(BITMAP* targetBitmap, const Vector& drawPos) const {
 	for (const PieSlice* pieSlice: m_CurrentPieSlices) {
 		BITMAP* pieSliceIcon = pieSlice->GetAppropriateIcon(pieSlice == m_HoveredPieSlice);

Source/Entities/PieMenu.h

@@ -404,8 +404,6 @@ namespace RTE {
 		/// @param drawPos Out parameter, a Vector to be filled in with the position at which the PieMenu should be drawn.
 		void CalculateDrawPosition(const BITMAP* targetBitmap, const Vector& targetPos, Vector& drawPos) const;
 
-
-		void DrawMenuBackground();
 		/// Handles drawing icons for PieSlices' visual representation in the PieMenu.
 		/// @param targetBitmap A pointer to the BITMAP to draw on. Generally a screen BITMAP.
 		/// @param drawPos The seam corrected position at which the PieMenu is being drawn.

Source/Entities/SLBackground.cpp

@@ -222,31 +222,21 @@ void SLBackground::Draw(const Box& targetDimensions, Box& targetBox, bool offset
 	int targetBoxWidth = static_cast<int>(targetBox.GetWidth());
 	int targetBoxHeight = static_cast<int>(targetBox.GetHeight());
 
-	//rlDrawRenderBatchActive();
-	//rlEnableScissorTest();
-	//glScissor(targetBoxCornerX, targetBoxCornerY, targetBoxCornerX + targetBoxWidth - 1, targetBoxCornerY + targetBoxHeight - 1);
-
 	// Detect if non-wrapping layer dimensions can't cover the whole target area with its main bitmap. If so, fill in the gap with appropriate solid color sampled from the hanging edge.
 	if (!m_WrapX && bitmapWidth <= targetBoxWidth) {
 		if (m_FillColorLeft != ColorKeys::g_MaskColor && m_Offset.GetFloorIntX() != 0) {
 			DrawRectangle(targetBoxCornerX, targetBoxCornerY, -m_Offset.m_X, targetBoxHeight, {static_cast<unsigned char>(m_FillColorLeft), 0, 0, 255});
-			// rectfill(targetBitmap, targetBoxCornerX, targetBoxCornerY, targetBoxCornerX - m_Offset.GetFloorIntX(), targetBoxCornerY + targetBoxHeight, m_FillColorLeft);
 		}
 		if (m_FillColorRight != ColorKeys::g_MaskColor) {
 			DrawRectangle(targetBoxCornerX + bitmapWidth - m_Offset.m_X, targetBoxCornerY, targetBoxWidth - bitmapWidth + m_Offset.m_X, targetBoxHeight, {static_cast<unsigned char>(m_FillColorRight), 0, 0, 255});
-			// rectfill(targetBitmap, targetBoxCornerX + bitmapWidth - m_Offset.GetFloorIntX(), targetBoxCornerY, targetBoxCornerX + targetBoxWidth, targetBoxCornerY + targetBoxHeight, m_FillColorRight);
 		}
 	}
 	if (!m_WrapY && bitmapHeight <= targetBoxHeight) {
 		if (m_FillColorUp != ColorKeys::g_MaskColor && m_Offset.GetFloorIntY() != 0) {
 			DrawRectangle(targetBoxCornerX, targetBoxCornerY, targetBoxWidth, - m_Offset.m_Y, {static_cast<unsigned char>(m_FillColorUp), 0, 0, 255});
-			// rectfill(targetBitmap, targetBoxCornerX, targetBoxCornerY, targetBoxCornerX + targetBoxWidth, targetBoxCornerY - m_Offset.GetFloorIntY(), m_FillColorUp);
 		}
 		if (m_FillColorDown != ColorKeys::g_MaskColor) {
 			DrawRectangle(targetBoxCornerX, targetBoxCornerY + bitmapHeight - m_Offset.m_Y, targetBoxWidth, targetBoxHeight - bitmapHeight + m_Offset.m_Y, {static_cast<unsigned char>(m_FillColorDown), 0, 0, 255});
-			// rectfill(targetBitmap, targetBoxCornerX, targetBoxCornerY + bitmapHeight - m_Offset.GetFloorIntY(), targetBoxCornerX + targetBoxWidth, targetBoxCornerY + targetBoxHeight, m_FillColorDown);
 		}
 	}
-	//rlDrawRenderBatchActive();
-	//rlDisableScissorTest();
 }

Source/Entities/SLTerrain.h

@@ -186,7 +186,7 @@ namespace RTE {
 		void Update() override;
 
 		/// Draws this SLTerrain's current scrolled position to a bitmap.
-		/// @param targetBitmap The bitmap to draw to.
+		/// @param targetDimensions Dimensions of the draw target.
 		/// @param targetBox The box on the target bitmap to limit drawing to, with the corner of box being where the scroll position lines up.
 		/// @param offsetNeedsScrollRatioAdjustment Whether the offset of this SceneLayer or the passed in offset override need to be adjusted to scroll ratio.
 		void Draw(const Box& targetDimensions, Box& targetBox, bool offsetNeedsScrollRatioAdjustment = false) override;

Source/Entities/SceneLayer.h

@@ -195,7 +195,7 @@ namespace RTE {
 		virtual void Update() {}
 
 		/// Draws this SceneLayer's current scrolled position to a bitmap.
-		/// @param targetBitmap The bitmap to draw to.
+		/// @param targetDimensions Dimensions of the draw target.
 		/// @param targetBox The box on the target bitmap to limit drawing to, with the corner of box being where the scroll position lines up.
 		/// @param offsetNeedsScrollRatioAdjustment Whether the offset of this SceneLayer or the passed in offset override need to be adjusted to scroll ratio.
 		virtual void Draw(const Box& targetDimensions, Box& targetBox, bool offsetNeedsScrollRatioAdjustment = false);
@@ -204,7 +204,7 @@ namespace RTE {
 	protected:
 		ContentFile m_BitmapFile; //!< ContentFile containing the path to this SceneLayer's sprite file.
 
-		std::unique_ptr<BigTexture> m_MainTexture;
+		std::unique_ptr<BigTexture> m_MainTexture; //!< The Main texture of this SceneLayer, may be tiled for very large scenes.
 		BITMAP* m_MainBitmap; //!< The main BITMAP of this SceneLayer.
 		BITMAP* m_BackBitmap; //!< The backbuffer BITMAP of this SceneLayer.
 
@@ -214,7 +214,7 @@ namespace RTE {
 		std::vector<IntRect> m_Drawings; //!< All the areas drawn within on this SceneLayer since the last clear.
 
 		bool m_MainBitmapOwned; //!< Whether the main bitmap is owned by this.
-		bool m_MainBitmapUpdated;
+		bool m_MainBitmapUpdated; //!< Whether the main bitmap was updated since the last draw.
 		bool m_DrawMasked; //!< Whether pixels marked as transparent (index 0, magenta) are skipped when drawing or not (masked drawing).
 
 		bool m_WrapX; //!< Whether wrapping is enabled on the X axis.
@@ -240,6 +240,9 @@ namespace RTE {
 		bool ForceBoundsOrWrapPosition(Vector& pos, bool forceBounds) const;
 
 #pragma region Draw Breakdown
+
+		/// @brief Update the target region of the current frontbuffer texture.
+		/// @param targetBox The region to update (will be wrapped if neccessary)
 		void UpdateTargetRegion(const Box& targetBox);
 
 		/// Performs tiled drawing of this SceneLayer's bitmap to the screen in cases where the target bitmap is larger in some dimension.
@@ -303,6 +306,7 @@ namespace RTE {
 		static Entity::ClassInfo m_sClass; //!< ClassInfo for this class.
 	};
 
+	/// SceneLayer that promises to never update its MainBitmap.
 	class StaticSceneLayer : public SceneLayerImpl<false, true> {
 	public:
 		EntityAllocation(StaticSceneLayer);

Source/Managers/FrameMan.cpp

@@ -269,7 +269,7 @@ void FrameMan::ResetSplitScreens(bool hSplit, bool vSplit) {
 		clear_to_color(m_PlayerScreen8.get(), 0);
 		set_clip_state(m_PlayerScreen8.get(), 1);
 
-		m_PlayerScreen = std::make_unique<RenderTarget>(FloatRect(0, 0, g_WindowMan.GetResX() / (m_VSplit ? 2 : 1), g_WindowMan.GetResY() / (m_HSplit ? 2 : 1)), FloatRect(0, 0, g_WindowMan.GetResX() / (m_VSplit ? 2 : 1), g_WindowMan.GetResY() / (m_HSplit ? 2 : 1)), 8, g_GLResourceMan.GetStaticTextureFromBitmap(m_PlayerScreen8.get()));
+		m_PlayerScreen = std::make_unique<RenderTarget>(FloatRect(0, 0, g_WindowMan.GetResX() / (m_VSplit ? 2 : 1), g_WindowMan.GetResY() / (m_HSplit ? 2 : 1)), FloatRect(0, 0, g_WindowMan.GetResX() / (m_VSplit ? 2 : 1), g_WindowMan.GetResY() / (m_HSplit ? 2 : 1)), 32, g_GLResourceMan.GetStaticTextureFromBitmap(m_PlayerScreen8.get()));
 
 		// Update these to represent the split screens
 		m_PlayerScreenWidth = m_PlayerScreen->GetSize().w;
@@ -811,14 +811,7 @@ void FrameMan::Draw() {
 	g_PresetMan.GetEntityPreset("Shader", "Background")->Clone(&backgroundShader);
 	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 	clear_to_color(m_BackBuffer8.get(), 0);
-	rlEnableColorBlend();
-	rlSetBlendMode(RL_BLEND_ALPHA);
-	rlEnableDepthTest();
 	m_BackBuffer->Begin(true);
-	backgroundShader.Begin();
-	backgroundShader.Enable();
-	rlSetUniformSampler(backgroundShader.GetUniformLocation("rtePalette"), g_PostProcessMan.GetPaletteTexture());
-	backgroundShader.SetInt("drawMasked", 1);
 
 	// Count how many split screens we'll need
 	int screenCount = (m_HSplit ? 2 : 1) * (m_VSplit ? 2 : 1);
@@ -835,9 +828,16 @@ void FrameMan::Draw() {
 	for (int playerScreen = 0; playerScreen < screenCount; ++playerScreen) {
 		screenRelativeEffects.clear();
 		screenRelativeGlowBoxes.clear();
+		rlEnableColorBlend();
+		rlSetBlendMode(RL_BLEND_ALPHA);
+		rlEnableDepthTest();
 
 		m_PlayerScreen->Begin(true);
-		
+		backgroundShader.Begin();
+		backgroundShader.Enable();
+		rlSetUniformSampler(backgroundShader.GetUniformLocation("rtePalette"), g_PostProcessMan.GetPaletteTexture());
+		backgroundShader.SetInt("drawMasked", 1);
+
 		//rlSetUniformSampler(backgroundShader.GetUniformLocation("rtePalette"), g_PostProcessMan.GetPaletteTexture());
 		BITMAP* drawScreen = (screenCount == 1) ? m_BackBuffer8.get() : m_PlayerScreen8.get();
 		BITMAP* drawScreenGUI = (screenCount == 1) ? m_BackBuffer8.get() : m_PlayerScreen8.get();
@@ -920,8 +920,12 @@ void FrameMan::Draw() {
 			// Draw the intermediate draw splitscreen to the appropriate spot on the back buffer
 			blit(drawScreen, m_BackBuffer8.get(), 0, 0, screenOffset.GetFloorIntX(), screenOffset.GetFloorIntY(), drawScreen->w, drawScreen->h);
 			m_PlayerScreen->End();
-			m_BackBuffer->Begin(false);
-			DrawTexture(g_GLResourceMan.GetStaticTextureFromBitmap(m_PlayerScreen8.get()), screenOffset.m_X, screenOffset.m_Y, {255, 255, 255, 255});
+			backgroundShader.End();
+			if (screenCount > 1) {
+				m_BackBuffer->Begin(false);
+				DrawTextureRec(g_GLResourceMan.GetStaticTextureFromBitmap(m_PlayerScreen8.get()), {0, 0, static_cast<float>(m_PlayerScreen8->w), -static_cast<float>(m_PlayerScreen8->h)}, {screenOffset.m_X, screenOffset.m_Y}, {255, 255, 255, 255});
+				m_BackBuffer->End();
+			}
 			g_PostProcessMan.AdjustEffectsPosToPlayerScreen(playerScreen, drawScreen, screenOffset, screenRelativeEffects, screenRelativeGlowBoxes);
 		}
 	}
@@ -960,9 +964,14 @@ void FrameMan::Draw() {
 	}
 	rlDisableDepthTest();
 	g_GLResourceMan.UpdateDynamicBitmap(m_BackBuffer8.get(), true);
+	backgroundShader.Begin();
+	backgroundShader.Enable();
+	rlSetUniformSampler(backgroundShader.GetUniformLocation("rtePalette"), g_PostProcessMan.GetPaletteTexture());
+	backgroundShader.SetInt("drawMasked", 1);
+	m_BackBuffer->Begin(false);
 	DrawTexture(g_GLResourceMan.GetStaticTextureFromBitmap(m_BackBuffer8.get()), 0.0f, 0.0f, {255, 255, 255, 255});
-	backgroundShader.End();
 	m_BackBuffer->End();
+	backgroundShader.End();
 	if (g_ActivityMan.IsInActivity()) {
 		g_PostProcessMan.PostProcess();
 	}

Source/Managers/FrameMan.h

@@ -335,6 +335,8 @@ namespace RTE {
 		/// @return An reference to a ContentFile which described the palette location.
 		const ContentFile& GetPaletteFile() const { return m_PaletteFile; }
 
+		/// Getter for the default palette for image loading purposes, etc.
+		/// @return Const reference to the default palette.
 		const PALETTE& GetDefaultPalette() const { return m_DefaultPalette; }
 
 		/// Fades the palette in from black at a specified speed.
@@ -400,7 +402,7 @@ namespace RTE {
 		/// The key is an array of the RGBA values. The value is a pair of the color table itself and a time stamp of when it was last accessed for use during color table pruning.
 		std::array<std::unordered_map<std::array<int, 4>, std::pair<COLOR_MAP, long long>>, DrawBlendMode::BlendModeCount> m_ColorTables;
 		Timer m_ColorTablePruneTimer; //!< Timer for pruning unused color tables to prevent ridiculous memory usage.
-		int m_CurrentAlpha;
+		int m_CurrentAlpha; //!< Current alpha level for emulating trans colortables.
 
 		std::shared_ptr<BITMAP> m_PlayerScreen8; //!< Intermediary split screen bitmap.
 		std::shared_ptr<RenderTarget> m_PlayerScreen; //!< Intermediary split screen bitmap.
@@ -438,7 +440,7 @@ namespace RTE {
 		std::unique_ptr<BITMAP, BitmapDeleter> m_NetworkBackBufferFinal8[2][c_MaxScreenCount]; //!< Per-player allocated frame buffer to copy Intermediate before sending.
 		std::unique_ptr<BITMAP, BitmapDeleter> m_NetworkBackBufferFinalGUI8[2][c_MaxScreenCount]; //!< Per-player allocated frame buffer to copy Intermediate before sending. Used to draw UI only.
 
-		std::shared_ptr<RenderTarget> m_BackBuffer;
+		std::shared_ptr<RenderTarget> m_BackBuffer; //!< Main render backbuffer.
 
 		Vector m_TargetPos[2][c_MaxScreenCount]; //!< Frame target position for network players.