Refactors to the code

Client/core/Graphics/CGraphics.h

@@ -348,6 +348,7 @@ class CGraphics : public CGraphicsInterface, public CSingleton<CGraphics>
     std::vector<sDrawQueueItem> m_PostGUIQueue;
 
     void AddQueueItem(const sDrawQueueItem& Item, bool bPostGUI);
+    sDrawQueueItem& CreateQueueItem(const bool bPostGUI);
     void DrawQueueItem(const sDrawQueueItem& Item);
     void DrawQueue(std::vector<sDrawQueueItem>& Queue);
     void ClearDrawQueue(std::vector<sDrawQueueItem>& Queue);

Client/core/Graphics/CRenderItemManager.cpp

@@ -312,8 +312,8 @@ CGuiFontItem* CRenderItemManager::CreateGuiFont(const SString& strFullFilePath,
 ////////////////////////////////////////////////////////////////
 void CRenderItemManager::NotifyContructRenderItem(CRenderItem* pItem)
 {
-    assert(!MapContains(m_CreatedItemList, pItem));
-    MapInsert(m_CreatedItemList, pItem);
+    const bool wasInserted = m_CreatedItemList.insert(pItem).second;
+    assert(wasInserted); // assert if item was already in the collection(and thus we didnt insert this)
 
     if (CScreenSourceItem* pScreenSourceItem = DynamicCast<CScreenSourceItem>(pItem))
         m_bBackBufferCopyMaybeNeedsResize = true;
@@ -328,8 +328,8 @@ void CRenderItemManager::NotifyContructRenderItem(CRenderItem* pItem)
 ////////////////////////////////////////////////////////////////
 void CRenderItemManager::NotifyDestructRenderItem(CRenderItem* pItem)
 {
-    assert(MapContains(m_CreatedItemList, pItem));
-    MapRemove(m_CreatedItemList, pItem);
+    const auto deletedCount = m_CreatedItemList.erase(pItem);
+    assert(deletedCount == 1); // it must be in the collection exactly once
 
     if (CScreenSourceItem* pScreenSourceItem = DynamicCast<CScreenSourceItem>(pItem))
         m_bBackBufferCopyMaybeNeedsResize = true;
@@ -453,9 +453,9 @@ void CRenderItemManager::UpdateBackBufferCopySize()
     // Set what the max size requirement is for the back buffer copy
     uint uiSizeX = 0;
     uint uiSizeY = 0;
-    for (std::set<CRenderItem*>::iterator iter = m_CreatedItemList.begin(); iter != m_CreatedItemList.end(); iter++)
+    for (const auto item : m_CreatedItemList)
     {
-        if (CScreenSourceItem* pScreenSourceItem = DynamicCast<CScreenSourceItem>(*iter))
+        if (CScreenSourceItem* pScreenSourceItem = DynamicCast<CScreenSourceItem>(item))
         {
             uiSizeX = std::max(uiSizeX, pScreenSourceItem->m_uiSizeX);
             uiSizeY = std::max(uiSizeY, pScreenSourceItem->m_uiSizeY);
@@ -631,7 +631,9 @@ void CRenderItemManager::ChangeRenderTarget(uint uiSizeX, uint uiSizeY, IDirect3
 //
 // CRenderItemManager::CanCreateRenderItem
 //
-//
+// Returns whenever a render item can be created
+// depending on the current set m_TestMode
+// Also checks if theres actually enough free video memory
 //
 ////////////////////////////////////////////////////////////////
 bool CRenderItemManager::CanCreateRenderItem(ClassId classId)
@@ -646,21 +648,22 @@ bool CRenderItemManager::CanCreateRenderItem(ClassId classId)
         if (m_iMemoryKBFreeForMTA <= 0)
             return false;
 
-        if (m_TestMode == DX_TEST_MODE_NO_MEM)
+        switch (m_TestMode)
+        {
+        case DX_TEST_MODE_NO_MEM:
             return false;
 
-        if (m_TestMode == DX_TEST_MODE_LOW_MEM)
-        {
-            if ((rand() % 1000) > 750)
-                return false;
+        case DX_TEST_MODE_LOW_MEM:
+            return (rand() % 1000) <= 750;
+
+        default:
+            return true;
         }
     }
     else if (classId == CShaderItem::GetClassId())
     {
-        if (m_TestMode == DX_TEST_MODE_NO_SHADER)
-            return false;
+        return m_TestMode != DX_TEST_MODE_NO_SHADER;
     }
-    return true;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -687,17 +690,20 @@ void CRenderItemManager::UpdateMemoryUsage()
     m_iTextureMemoryKBUsed = 0;
     m_iRenderTargetMemoryKBUsed = 0;
     m_iFontMemoryKBUsed = 0;
-    for (std::set<CRenderItem*>::iterator iter = m_CreatedItemList.begin(); iter != m_CreatedItemList.end(); iter++)
+
+    for (const auto pRenderItem : m_CreatedItemList)
     {
-        CRenderItem* pRenderItem = *iter;
         if (!pRenderItem->GetIncludeInMemoryStats())
             continue;
-        int iMemoryKBUsed = pRenderItem->GetVideoMemoryKBUsed();
+
+        const int iMemoryKBUsed = pRenderItem->GetVideoMemoryKBUsed();
 
         if (pRenderItem->IsA(CFileTextureItem::GetClassId()))
             m_iTextureMemoryKBUsed += iMemoryKBUsed;
+
         else if (pRenderItem->IsA(CRenderTargetItem::GetClassId()) || pRenderItem->IsA(CScreenSourceItem::GetClassId()))
             m_iRenderTargetMemoryKBUsed += iMemoryKBUsed;
+
         else if (pRenderItem->IsA(CGuiFontItem::GetClassId()) || pRenderItem->IsA(CDxFontItem::GetClassId()))
             m_iFontMemoryKBUsed += iMemoryKBUsed;
     }
@@ -776,21 +782,20 @@ void CRenderItemManager::GetDxStatus(SDxStatus& outStatus)
     }
 
     // Display color depth
-    D3DFORMAT BackBufferFormat = g_pDeviceState->CreationState.PresentationParameters.BackBufferFormat;
-    if (BackBufferFormat >= D3DFMT_R5G6B5 && BackBufferFormat < D3DFMT_A8R3G3B2)
-        outStatus.settings.b32BitColor = 0;
-    else
-        outStatus.settings.b32BitColor = 1;
+    outStatus.settings.b32BitColor = GetBitsPerPixel(g_pDeviceState->CreationState.PresentationParameters.BackBufferFormat) == 32;
 
     // Modify if using test mode
-    if (m_TestMode == DX_TEST_MODE_NO_MEM)
+    switch (m_TestMode)
+    {
+    case DX_TEST_MODE_NO_MEM:
         outStatus.videoMemoryKB.iFreeForMTA = 0;
 
-    if (m_TestMode == DX_TEST_MODE_LOW_MEM)
+    case DX_TEST_MODE_LOW_MEM:
         outStatus.videoMemoryKB.iFreeForMTA = 1;
 
-    if (m_TestMode == DX_TEST_MODE_NO_SHADER)
+    case DX_TEST_MODE_NO_SHADER:
         outStatus.videoCard.strPSVersion = "0";
+    }
 }
 
 ////////////////////////////////////////////////////////////////
@@ -886,21 +891,23 @@ int CRenderItemManager::GetPitchDivisor(D3DFORMAT Format)
 ////////////////////////////////////////////////////////////////
 int CRenderItemManager::CalcD3DResourceMemoryKBUsage(IDirect3DResource9* pD3DResource)
 {
-    D3DRESOURCETYPE type = pD3DResource->GetType();
-
-    if (type == D3DRTYPE_SURFACE)
+    switch (pD3DResource->GetType())
+    {
+    case D3DRTYPE_SURFACE:
         return CalcD3DSurfaceMemoryKBUsage((IDirect3DSurface9*)pD3DResource);
 
-    if (type == D3DRTYPE_TEXTURE)
+    case D3DRTYPE_TEXTURE:
         return CalcD3DTextureMemoryKBUsage((IDirect3DTexture9*)pD3DResource);
 
-    if (type == D3DRTYPE_VOLUMETEXTURE)
+    case D3DRTYPE_VOLUMETEXTURE:
         return CalcD3DVolumeTextureMemoryKBUsage((IDirect3DVolumeTexture9*)pD3DResource);
 
-    if (type == D3DRTYPE_CUBETEXTURE)
+    case D3DRTYPE_CUBETEXTURE:
         return CalcD3DCubeTextureMemoryKBUsage((IDirect3DCubeTexture9*)pD3DResource);
 
-    return 0;
+    default:
+        return 0;
+    }
 }
 
 ////////////////////////////////////////////////////////////////
@@ -915,10 +922,10 @@ int CRenderItemManager::CalcD3DSurfaceMemoryKBUsage(IDirect3DSurface9* pD3DSurfa
     D3DSURFACE_DESC surfaceDesc;
     pD3DSurface->GetDesc(&surfaceDesc);
 
-    int iBitsPerPixel = GetBitsPerPixel(surfaceDesc.Format);
-    int iMemoryUsed = surfaceDesc.Width * surfaceDesc.Height / 8 * iBitsPerPixel;
+    const int iBitsPerPixel = GetBitsPerPixel(surfaceDesc.Format);
+    const int iMemoryUsedBytes = (surfaceDesc.Width * surfaceDesc.Height * iBitsPerPixel) / 8;
 
-    return iMemoryUsed / 1024;
+    return iMemoryUsedBytes / 1024;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -933,7 +940,7 @@ int CRenderItemManager::CalcD3DTextureMemoryKBUsage(IDirect3DTexture9* pD3DTextu
     int iMemoryUsed = 0;
 
     // Calc memory usage
-    int iLevelCount = pD3DTexture->GetLevelCount();
+    const int iLevelCount = pD3DTexture->GetLevelCount();
     for (int i = 0; i < iLevelCount; i++)
     {
         D3DSURFACE_DESC surfaceDesc;
@@ -955,20 +962,20 @@ int CRenderItemManager::CalcD3DTextureMemoryKBUsage(IDirect3DTexture9* pD3DTextu
 ////////////////////////////////////////////////////////////////
 int CRenderItemManager::CalcD3DVolumeTextureMemoryKBUsage(IDirect3DVolumeTexture9* pD3DVolumeTexture)
 {
-    int iMemoryUsed = 0;
+    int iMemoryUsedBytes = 0;
 
     // Calc memory usage
-    int iLevelCount = pD3DVolumeTexture->GetLevelCount();
+    const int iLevelCount = pD3DVolumeTexture->GetLevelCount();
     for (int i = 0; i < iLevelCount; i++)
     {
         D3DVOLUME_DESC volumeDesc;
         pD3DVolumeTexture->GetLevelDesc(i, &volumeDesc);
 
         int iBitsPerPixel = GetBitsPerPixel(volumeDesc.Format);
-        iMemoryUsed += volumeDesc.Width * volumeDesc.Height * volumeDesc.Depth / 8 * iBitsPerPixel;
+        iMemoryUsedBytes += (volumeDesc.Width * volumeDesc.Height * volumeDesc.Depth * iBitsPerPixel) / 8;
     }
 
-    return iMemoryUsed / 1024;
+    return iMemoryUsedBytes / 1024;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -980,20 +987,20 @@ int CRenderItemManager::CalcD3DVolumeTextureMemoryKBUsage(IDirect3DVolumeTexture
 ////////////////////////////////////////////////////////////////
 int CRenderItemManager::CalcD3DCubeTextureMemoryKBUsage(IDirect3DCubeTexture9* pD3DCubeTexture)
 {
-    int iMemoryUsed = 0;
+    int iMemoryUsedBytes = 0;
 
     // Calc memory usage
-    int iLevelCount = pD3DCubeTexture->GetLevelCount();
+    const int iLevelCount = pD3DCubeTexture->GetLevelCount();
     for (int i = 0; i < iLevelCount; i++)
     {
         D3DSURFACE_DESC surfaceDesc;
         pD3DCubeTexture->GetLevelDesc(i, &surfaceDesc);
 
-        int iBitsPerPixel = GetBitsPerPixel(surfaceDesc.Format);
-        iMemoryUsed += surfaceDesc.Width * surfaceDesc.Height / 8 * iBitsPerPixel;
+        const int iBitsPerPixel = GetBitsPerPixel(surfaceDesc.Format);
+        iMemoryUsedBytes += (surfaceDesc.Width * surfaceDesc.Height * iBitsPerPixel) / 8;
     }
 
-    return iMemoryUsed * 6 / 1024;
+    return iMemoryUsedBytes * 6 / 1024;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -1070,6 +1077,7 @@ void CRenderItemManager::PreDrawWorld()
         m_pDevice->CreateTexture(m_uiDefaultViewportSizeX, m_uiDefaultViewportSizeY, 1, D3DUSAGE_DEPTHSTENCIL, (D3DFORMAT)m_depthBufferFormat, D3DPOOL_DEFAULT,
                                  &pReadableDepthBuffer, NULL);
     }
+
     if (bRequireNonAADisplay && !m_pNonAARenderTarget)
     {
         // Create a non-AA render target and depth buffer

Client/sdk/core/CGraphicsInterface.h

@@ -20,6 +20,13 @@ struct PrimitiveVertice
     static const uint FNV = D3DFVF_XYZ | D3DFVF_DIFFUSE;
     float             fX, fY, fZ;
     D3DCOLOR          Color;
+
+    PrimitiveVertice(float x, float y, float z, D3DCOLOR color) :
+        fX(x),
+        fY(y),
+        fZ(z),
+        Color(color)
+    {}
 };
 struct PrimitiveMaterialVertice
 {