Added black outline option for chat text in settings

ccw808 · ccw808 · commit daccaa040ca2 · 2017-06-20T02:24:52.000+01:00
diff --git a/Client/core/CChat.cpp b/Client/core/CChat.cpp
@@ -119,6 +119,7 @@ void CChat::LoadCVars ( void )
     CVARS_GET ( "chat_text_color",              m_TextColor );
     CVARS_GET ( "chat_scale",                   m_vecScale );
     CVARS_GET ( "chat_width",                   fWidth );               if( m_bCanChangeWidth ) m_fNativeWidth = fWidth * CHAT_WIDTH;
+    CVARS_GET ( "chat_text_outline",            m_bTextBlackOutline );
     CVARS_GET ( "chat_css_style_text",          m_bCssStyleText );
     CVARS_GET ( "chat_css_style_background",    m_bCssStyleBackground );
     CVARS_GET ( "chat_line_life",               (unsigned int &)m_ulChatLineLife );
@@ -248,7 +249,7 @@ void CChat::DrawDrawList ( const SDrawList& drawList, const CVector2D& topLeftOf
     for ( uint i = 0 ; i < drawList.lineItemList.size () ; i++ )
     {
         const SDrawListLineItem& item = drawList.lineItemList[i];
-        m_Lines [ item.uiLine ].Draw ( item.vecPosition - chatTopLeft + topLeftOffset, item.ucAlpha, drawList.bShadow, chatBounds );
+        m_Lines [ item.uiLine ].Draw ( item.vecPosition - chatTopLeft + topLeftOffset, item.ucAlpha, drawList.bShadow, drawList.bOutline, chatBounds );
     }
 
     CGraphics::GetSingleton ().EndDrawBatch ();
@@ -265,8 +266,8 @@ void CChat::GetDrawList ( SDrawList& outDrawList )
     CVector2D vecPosition ( m_vecBackgroundPosition.fX + ( 5.0f * m_vecScale.fX ), m_vecBackgroundPosition.fY + m_vecBackgroundSize.fY - ( fLineDifference * 1.25f ) );
     unsigned long ulTime = GetTickCount32 ();
     float fRcpChatLineFadeOut = 1.0f / m_ulChatLineFadeOut;
-    bool bShadow = ( m_Color.A * m_fBackgroundAlpha == 0.f );
-    bool bInputShadow = ( m_InputColor.A * m_fInputBackgroundAlpha == 0.f );
+    bool bShadow = ( m_Color.A * m_fBackgroundAlpha == 0.f ) && !m_bTextBlackOutline;
+    bool bInputShadow = ( m_InputColor.A * m_fInputBackgroundAlpha == 0.f ) && !m_bTextBlackOutline;
 
     if ( m_Color.A * m_fBackgroundAlpha > 0.f )
     {
@@ -291,6 +292,7 @@ void CChat::GetDrawList ( SDrawList& outDrawList )
 
     outDrawList.renderBounds = RenderBounds;
     outDrawList.bShadow = bShadow;
+    outDrawList.bOutline = m_bTextBlackOutline;
 
     // Smooth scroll
     int iLineScroll;
@@ -346,7 +348,7 @@ void CChat::GetDrawList ( SDrawList& outDrawList )
     if ( m_bInputVisible )
     {
         CVector2D vecPosition ( m_vecInputPosition.fX + ( 5.0f * m_vecScale.fX ), m_vecInputPosition.fY + ( fLineDifference * 0.125f ) );
-        m_InputLine.Draw ( vecPosition, 255, bInputShadow );
+        m_InputLine.Draw ( vecPosition, 255, bInputShadow, m_bTextBlackOutline );
     }
 }
 
@@ -905,7 +907,7 @@ float CChat::GetTextExtent ( const char * szText, float fScale )
 }
 
 
-void CChat::DrawTextString ( const char * szText, CRect2D DrawArea, float fZ, CRect2D ClipRect, unsigned long ulFormat, unsigned long ulColor, float fScaleX, float fScaleY, const CRect2D& RenderBounds )
+void CChat::DrawTextString ( const char * szText, CRect2D DrawArea, float fZ, CRect2D ClipRect, unsigned long ulFormat, unsigned long ulColor, float fScaleX, float fScaleY, bool bOutline, const CRect2D& RenderBounds )
 {
     if ( !g_pChat )
         return;
@@ -924,19 +926,19 @@ void CChat::DrawTextString ( const char * szText, CRect2D DrawArea, float fZ, CR
         {
             // Clip text at the top
             if ( DrawArea.fY1 + fLineHeight - RenderBounds.fY1 > 1 )
-               g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) RenderBounds.fY1, ( int ) DrawArea.fX2, ( int ) DrawArea.fY1 + fLineHeight, ulColor, szText, fScaleX, fScaleY, DT_LEFT | DT_BOTTOM | DT_SINGLELINE , g_pChat->m_pDXFont );
+               g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) RenderBounds.fY1, ( int ) DrawArea.fX2, ( int ) DrawArea.fY1 + fLineHeight, ulColor, szText, fScaleX, fScaleY, DT_LEFT | DT_BOTTOM | DT_SINGLELINE , g_pChat->m_pDXFont, bOutline );
         }
         else
         if ( DrawArea.fY1 + fLineHeight > RenderBounds.fY2 )
         {
             // Clip text at the bottom
             if ( RenderBounds.fY2 - DrawArea.fY1 > 1 )
-                g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX2, ( int ) RenderBounds.fY2, ulColor, szText, fScaleX, fScaleY, DT_LEFT | DT_TOP | DT_SINGLELINE , g_pChat->m_pDXFont );
+                g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX2, ( int ) RenderBounds.fY2, ulColor, szText, fScaleX, fScaleY, DT_LEFT | DT_TOP | DT_SINGLELINE , g_pChat->m_pDXFont, bOutline );
         }
         else
         {
             // Text not clipped
-            g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ulColor, szText, fScaleX, fScaleY, DT_LEFT | DT_TOP | DT_NOCLIP, g_pChat->m_pDXFont );
+            g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ulColor, szText, fScaleX, fScaleY, DT_LEFT | DT_TOP | DT_NOCLIP, g_pChat->m_pDXFont, bOutline );
         }
     }
 }
@@ -1058,13 +1060,13 @@ const char* CChatLine::Format ( const char* szStringAnsi, float fWidth, CColor&
 }
 
 
-void CChatLine::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, const CRect2D& RenderBounds )
+void CChatLine::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline, const CRect2D& RenderBounds )
 {
     float fCurrentX = vecPosition.fX;
     std::vector < CChatLineSection >::iterator iter = m_Sections.begin ();
     for ( ; iter != m_Sections.end () ; iter++ )
     {
-        (*iter).Draw ( CVector2D ( fCurrentX, vecPosition.fY ), ucAlpha, bShadow, RenderBounds );
+        (*iter).Draw ( CVector2D ( fCurrentX, vecPosition.fY ), ucAlpha, bShadow, bOutline, RenderBounds );
         fCurrentX += (*iter).GetWidth ();
     }
 }
@@ -1082,27 +1084,27 @@ float CChatLine::GetWidth ()
 }
 
 
-void CChatInputLine::Draw ( CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow )
+void CChatInputLine::Draw ( CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline )
 {
     CRect2D RenderBounds ( 0, 0, 9999, 9999 );
 
     CColor colPrefix;
     m_Prefix.GetColor ( colPrefix );
     if ( colPrefix.A > 0 )
-        m_Prefix.Draw ( vecPosition, colPrefix.A, bShadow, RenderBounds );
+        m_Prefix.Draw ( vecPosition, colPrefix.A, bShadow, bOutline, RenderBounds );
     
     if ( g_pChat->m_InputTextColor.A > 0 && m_Sections.size () > 0 )
     {
         m_Sections [ 0 ].Draw ( CVector2D ( vecPosition.fX + m_Prefix.GetWidth (), vecPosition.fY ),
-            g_pChat->m_InputTextColor.A, bShadow, RenderBounds );
+            g_pChat->m_InputTextColor.A, bShadow, bOutline, RenderBounds );
 
         float fLineDifference = CChat::GetFontHeight ( g_pChat->m_vecScale.fY );
 
         vector < CChatLine >::iterator iter = m_ExtraLines.begin ();
         for ( ; iter != m_ExtraLines.end () ; iter++ )
         {
             vecPosition.fY += fLineDifference;
-            (*iter).Draw ( vecPosition, g_pChat->m_InputTextColor.A, bShadow, RenderBounds );
+            (*iter).Draw ( vecPosition, g_pChat->m_InputTextColor.A, bShadow, bOutline, RenderBounds );
         }
     }
 }
@@ -1134,17 +1136,17 @@ CChatLineSection& CChatLineSection::operator = ( const CChatLineSection& other )
     return *this;
 }
 
-void CChatLineSection::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, const CRect2D& RenderBounds )
+void CChatLineSection::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline, const CRect2D& RenderBounds )
 {
     if ( !m_strText.empty () && ucAlpha > 0 )
     {
         if ( bShadow )
         {
             CRect2D drawShadowAt ( vecPosition.fX + 1.0f, vecPosition.fY + 1.0f, vecPosition.fX + 1000.0f, vecPosition.fY + 1000.0f );
-            CChat::DrawTextString ( m_strText.c_str (), drawShadowAt, 0.0f, drawShadowAt, 0, COLOR_ARGB ( ucAlpha, 0, 0, 0 ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, RenderBounds );                
+            CChat::DrawTextString ( m_strText.c_str (), drawShadowAt, 0.0f, drawShadowAt, 0, COLOR_ARGB ( ucAlpha, 0, 0, 0 ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, bOutline, RenderBounds );                
         }
         CRect2D drawAt ( vecPosition.fX, vecPosition.fY, vecPosition.fX + 1000.0f, vecPosition.fY + 1000.0f );
-        CChat::DrawTextString ( m_strText.c_str (), drawAt, 0.0f, drawAt, 0, COLOR_ARGB ( ucAlpha, m_Color.R, m_Color.G, m_Color.B ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, RenderBounds );
+        CChat::DrawTextString ( m_strText.c_str (), drawAt, 0.0f, drawAt, 0, COLOR_ARGB ( ucAlpha, m_Color.R, m_Color.G, m_Color.B ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, bOutline, RenderBounds );
     }
 }
 
diff --git a/Client/core/CChat.h b/Client/core/CChat.h
@@ -82,7 +82,7 @@ class CChatLineSection
 
     CChatLineSection&           operator =              ( const CChatLineSection& other );
 
-    void                        Draw                    ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, const CRect2D& RenderBounds );
+    void                        Draw                    ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline, const CRect2D& RenderBounds );
     float                       GetWidth                ( void );
     inline const char*          GetText                 ( void )            { return m_strText.c_str (); }
     void                        SetText                 ( const char* szText )  { m_strText = szText; }
@@ -102,7 +102,7 @@ class CChatLine
                                 CChatLine               ( void );
 
     virtual const char*         Format                  ( const char* szText, float fWidth, CColor& color, bool bColorCoded );
-    virtual void                Draw                    ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, const CRect2D& RenderBounds );    
+    virtual void                Draw                    ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline, const CRect2D& RenderBounds );    
     virtual float               GetWidth                ( void );
     bool                        IsActive                ( void )    { return m_bActive; }
     void                        SetActive               ( bool bActive )    { m_bActive = bActive; }
@@ -120,7 +120,7 @@ class CChatLine
 class CChatInputLine : public CChatLine
 {
 public:
-    void                        Draw                    ( CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow );
+    void                        Draw                    ( CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline );
     void                        Clear                   ( void );
 
     CChatLineSection            m_Prefix;
@@ -157,6 +157,7 @@ struct SDrawList
 {
     CRect2D                             renderBounds;
     bool                                bShadow;
+    bool                                bOutline;
     std::vector < SDrawListLineItem >   lineItemList;
 
     bool operator!= ( const SDrawList& other ) const
@@ -167,6 +168,7 @@ struct SDrawList
     {
         if ( lineItemList.size () != other.lineItemList.size ()
           || bShadow != other.bShadow
+          || bOutline != other.bOutline
           || renderBounds != other.renderBounds )
             return false;
 
@@ -213,7 +215,7 @@ class CChat
 
     static float                GetFontHeight           ( float fScale = 1.0f );
     static float                GetTextExtent           ( const char * szText, float fScale = 1.0f );
-    static void                 DrawTextString          ( const char * szText, CRect2D DrawArea, float fZ, CRect2D ClipRect, unsigned long ulFormat, unsigned long ulColor, float fScaleX, float fScaleY, const CRect2D& RenderBounds );
+    static void                 DrawTextString          ( const char * szText, CRect2D DrawArea, float fZ, CRect2D ClipRect, unsigned long ulFormat, unsigned long ulColor, float fScaleX, float fScaleY, bool bOutline, const CRect2D& RenderBounds );
 
     void                        SetColor                ( const CColor& Color );
     void                        SetInputColor           ( const CColor& Color );
@@ -280,6 +282,7 @@ class CChat
     CColor                      m_InputTextColor;
     bool                        m_bCssStyleText;
     bool                        m_bCssStyleBackground;
+    bool                        m_bTextBlackOutline;
     unsigned long               m_ulChatLineLife;
     unsigned long               m_ulChatLineFadeOut;
     bool                        m_bUseCEGUI;
diff --git a/Client/core/CSettings.cpp b/Client/core/CSettings.cpp
@@ -1111,8 +1111,9 @@ void CSettings::CreateGUI ( void )
         pLabel->GetSize ( vecSize );
         pLabel->SetFont ( "default-bold-small" );
 
+        fLineHeight = 17.0f;
         m_pChatCssBackground = reinterpret_cast < CGUICheckBox* > ( pManager->CreateCheckBox( pTabInterface, _("Hide background when not typing") ) );
-        m_pChatCssBackground->SetPosition ( CVector2D ( vecTemp.fX, vecTemp.fY + fFontNamesMarginY ) );
+        m_pChatCssBackground->SetPosition ( CVector2D ( vecTemp.fX, vecTemp.fY + fFontNamesMarginY - 2 ) );
         m_pChatCssBackground->GetPosition ( vecTemp );
         m_pChatCssBackground->AutoSize ( NULL, 20.0f );
 
@@ -1130,6 +1131,11 @@ void CSettings::CreateGUI ( void )
         m_pTrayBalloon->SetPosition ( CVector2D ( vecTemp.fX, vecTemp.fY + fLineHeight ) );
         m_pTrayBalloon->GetPosition ( vecTemp );
         m_pTrayBalloon->AutoSize ( NULL, 20.0f );
+
+        m_pChatTextBlackOutline = reinterpret_cast < CGUICheckBox* > ( pManager->CreateCheckBox ( pTabInterface, _("Chat text black outline") ) );
+        m_pChatTextBlackOutline->SetPosition ( CVector2D ( vecTemp.fX, vecTemp.fY + fLineHeight ) );
+        m_pChatTextBlackOutline->GetPosition ( vecTemp );
+        m_pChatTextBlackOutline->AutoSize ( NULL, 20.0f );
     }
 
     /**
@@ -2884,6 +2890,7 @@ void CSettings::LoadData ( void )
     CVARS_GET ( "chat_css_style_text", bVar ); m_pChatCssText->SetSelected ( bVar );
     CVARS_GET ( "chat_css_style_background", bVar ); m_pChatCssBackground->SetSelected ( bVar );
     CVARS_GET ( "chat_nickcompletion", bVar ); m_pChatNickCompletion->SetSelected ( bVar );
+    CVARS_GET ( "chat_text_outline", bVar ); m_pChatTextBlackOutline->SetSelected ( bVar );
 
     {
         int iVar;
@@ -3198,6 +3205,7 @@ void CSettings::SaveData ( void )
     CVARS_SET ( "chat_css_style_text", m_pChatCssText->GetSelected () );
     CVARS_SET ( "chat_css_style_background", m_pChatCssBackground->GetSelected () );
     CVARS_SET ( "chat_nickcompletion", m_pChatNickCompletion->GetSelected () );
+    CVARS_SET ( "chat_text_outline", m_pChatTextBlackOutline->GetSelected() );
     CVARS_SET ( "chat_line_life", GetMilliseconds ( m_pChatLineLife ) );
     CVARS_SET ( "chat_line_fade_out", GetMilliseconds ( m_pChatLineFadeout ) );
 
diff --git a/Client/core/CSettings.h b/Client/core/CSettings.h
@@ -315,6 +315,7 @@ class CSettings
     CGUICheckBox*       m_pChatCssBackground;
     CGUICheckBox*       m_pChatNickCompletion;
     CGUICheckBox*       m_pChatCssText;
+    CGUICheckBox*       m_pChatTextBlackOutline;
     CGUIEdit*           m_pChatLineLife;
     CGUIEdit*           m_pChatLineFadeout;
     CGUICheckBox*       m_pFlashWindow;
diff --git a/Client/core/Graphics/CGraphics.cpp b/Client/core/Graphics/CGraphics.cpp
@@ -74,7 +74,7 @@ CGraphics::~CGraphics ( void )
 }
 
 
-void CGraphics::DrawString ( int uiLeft, int uiTop, int uiRight, int uiBottom, unsigned long ulColor, const char* szText, float fScaleX, float fScaleY, unsigned long ulFormat, LPD3DXFONT pDXFont )
+void CGraphics::DrawString ( int uiLeft, int uiTop, int uiRight, int uiBottom, unsigned long ulColor, const char* szText, float fScaleX, float fScaleY, unsigned long ulFormat, LPD3DXFONT pDXFont, bool bOutline )
 {   
     if ( g_pCore->IsWindowMinimized () )
         return;
@@ -114,6 +114,8 @@ void CGraphics::DrawString ( int uiLeft, int uiTop, int uiRight, int uiBottom, u
             // Convert to UTF16
             std::wstring strText = MbUTF8ToUTF16(szText);
 
+            if ( bOutline )
+                DrawStringBlurred( rect, ulColor & 0xFF000000, strText.c_str(), ulFormat, pDXFont );
             pDXFont->DrawTextW ( m_pDXSprite, strText.c_str(), -1, &rect, ulFormat, ulColor );
         EndDrawBatch ();
     }        
@@ -131,6 +133,45 @@ void CGraphics::DrawString ( int iX, int iY, unsigned long dwColor, float fScale
     DrawString ( iX, iY, iX, iY, dwColor, szBuffer, fScale, fScale, DT_NOCLIP );
 }
 
+// Slow
+void CGraphics::DrawStringBlurred(const RECT& rect, unsigned long ulColor, const wchar_t* szText, unsigned long ulFormat, LPD3DXFONT pDXFont)
+{
+    // Blur definition
+    const float E = 0;
+    const float D = 0.33f;
+    const float C = 0.66f;
+    const float B = 1;
+    const float A = 0;
+    static const float kernelData[] = {
+                            E, D, D, D, E,
+                            D, C, B, C, D,
+                            D, B, A, B, D,
+                            D, C, B, C, D,
+                            E, D, D, D, E };
+    const uint uiKernelSizeX = 5;
+    const uint uiKernelSizeY = 5;
+    const float* pKernel = kernelData;
+
+    // Apply definition
+    int iInputAlpha = (ulColor & 0xFF000000) >> 24;
+    iInputAlpha = iInputAlpha * iInputAlpha / 256;
+    for (uint y = 0; y < uiKernelSizeY; y++)
+    {
+        for (uint x = 0; x < uiKernelSizeX; x++)
+        {
+            float fAlpha = *pKernel++;
+            if ( fAlpha == 0 )
+                continue;
+            uint uiUseAlpha = (uint)(iInputAlpha * fAlpha);
+            uint uiUseColor = (uiUseAlpha << 24) | (ulColor & 0x00FFFFFF);
+            int iOffsetX = x - (uiKernelSizeX - 1) / 2;
+            int iOffsetY = y - (uiKernelSizeY - 1) / 2;
+            RECT useRect = {rect.left + iOffsetX, rect.top + iOffsetY, rect.right + iOffsetX, rect.bottom + iOffsetY};        
+            pDXFont->DrawTextW(m_pDXSprite, szText, -1, &useRect, ulFormat, uiUseColor);
+        }
+    }
+}
+
 
 void CGraphics::DrawLine3D ( const CVector& vecBegin, const CVector& vecEnd, unsigned long ulColor, float fWidth )
 {
diff --git a/Client/core/Graphics/CGraphics.h b/Client/core/Graphics/CGraphics.h
@@ -78,10 +78,11 @@ class CGraphics : public CGraphicsInterface, public CSingleton < CGraphics >
     void                CalcScreenCoors         ( CVector * vecWorld, CVector * vecScreen );
 
     // DirectX drawing functions
-    void                DrawString              ( int iLeft, int iTop, int iRight, int iBottom, unsigned long dwColor, const char* wszText, float fScaleX, float fScaleY, unsigned long ulFormat, ID3DXFont * pDXFont = NULL );
+    void                DrawString              ( int iLeft, int iTop, int iRight, int iBottom, unsigned long dwColor, const char* wszText, float fScaleX, float fScaleY, unsigned long ulFormat, ID3DXFont * pDXFont = NULL, bool bOutline = false );
     void                DrawString              ( int iX, int iY, unsigned long dwColor, float fScale, const char * szText, ... );
     void                DrawLine3D              ( const CVector& vecBegin, const CVector& vecEnd, unsigned long ulColor, float fWidth = 1.0f );
     void                DrawRectangle           ( float fX, float fY, float fWidth, float fHeight, unsigned long ulColor, bool bSubPixelPositioning = false );
+    void                DrawStringBlurred       ( const RECT& rect, unsigned long ulColor, const wchar_t* szText, unsigned long ulFormat, LPD3DXFONT pDXFont );
 
     void                SetBlendMode            ( EBlendModeType blendMode );
     EBlendModeType      GetBlendMode            ( void );
diff --git a/Client/sdk/core/CGraphicsInterface.h b/Client/sdk/core/CGraphicsInterface.h

Original file line number	Diff line number	Diff line change
`@@ -119,6 +119,7 @@ void CChat::LoadCVars ( void )`
`119`	`119`	`CVARS_GET ( "chat_text_color", m_TextColor );`
`120`	`120`	`CVARS_GET ( "chat_scale", m_vecScale );`
`121`	`121`	`CVARS_GET ( "chat_width", fWidth ); if( m_bCanChangeWidth ) m_fNativeWidth = fWidth * CHAT_WIDTH;`
	`122`	`+ CVARS_GET ( "chat_text_outline", m_bTextBlackOutline );`
`122`	`123`	`CVARS_GET ( "chat_css_style_text", m_bCssStyleText );`
`123`	`124`	`CVARS_GET ( "chat_css_style_background", m_bCssStyleBackground );`
`124`	`125`	`CVARS_GET ( "chat_line_life", (unsigned int &)m_ulChatLineLife );`
`@@ -248,7 +249,7 @@ void CChat::DrawDrawList ( const SDrawList& drawList, const CVector2D& topLeftOf`
`248`	`249`	`for ( uint i = 0 ; i < drawList.lineItemList.size () ; i++ )`
`249`	`250`	`{`
`250`	`251`	`const SDrawListLineItem& item = drawList.lineItemList[i];`
`251`		`- m_Lines [ item.uiLine ].Draw ( item.vecPosition - chatTopLeft + topLeftOffset, item.ucAlpha, drawList.bShadow, chatBounds );`
	`252`	`+ m_Lines [ item.uiLine ].Draw ( item.vecPosition - chatTopLeft + topLeftOffset, item.ucAlpha, drawList.bShadow, drawList.bOutline, chatBounds );`
`252`	`253`	`}`
`253`	`254`
`254`	`255`	`CGraphics::GetSingleton ().EndDrawBatch ();`
`@@ -265,8 +266,8 @@ void CChat::GetDrawList ( SDrawList& outDrawList )`
`265`	`266`	`CVector2D vecPosition ( m_vecBackgroundPosition.fX + ( 5.0f * m_vecScale.fX ), m_vecBackgroundPosition.fY + m_vecBackgroundSize.fY - ( fLineDifference * 1.25f ) );`
`266`	`267`	`unsigned long ulTime = GetTickCount32 ();`
`267`	`268`	`float fRcpChatLineFadeOut = 1.0f / m_ulChatLineFadeOut;`
`268`		`- bool bShadow = ( m_Color.A * m_fBackgroundAlpha == 0.f );`
`269`		`- bool bInputShadow = ( m_InputColor.A * m_fInputBackgroundAlpha == 0.f );`
	`269`	`+ bool bShadow = ( m_Color.A * m_fBackgroundAlpha == 0.f ) && !m_bTextBlackOutline;`
	`270`	`+ bool bInputShadow = ( m_InputColor.A * m_fInputBackgroundAlpha == 0.f ) && !m_bTextBlackOutline;`
`270`	`271`
`271`	`272`	`if ( m_Color.A * m_fBackgroundAlpha > 0.f )`
`272`	`273`	`{`
`@@ -291,6 +292,7 @@ void CChat::GetDrawList ( SDrawList& outDrawList )`
`291`	`292`
`292`	`293`	`outDrawList.renderBounds = RenderBounds;`
`293`	`294`	`outDrawList.bShadow = bShadow;`
	`295`	`+ outDrawList.bOutline = m_bTextBlackOutline;`
`294`	`296`
`295`	`297`	`// Smooth scroll`
`296`	`298`	`int iLineScroll;`
`@@ -346,7 +348,7 @@ void CChat::GetDrawList ( SDrawList& outDrawList )`
`346`	`348`	`if ( m_bInputVisible )`
`347`	`349`	`{`
`348`	`350`	`CVector2D vecPosition ( m_vecInputPosition.fX + ( 5.0f * m_vecScale.fX ), m_vecInputPosition.fY + ( fLineDifference * 0.125f ) );`
`349`		`- m_InputLine.Draw ( vecPosition, 255, bInputShadow );`
	`351`	`+ m_InputLine.Draw ( vecPosition, 255, bInputShadow, m_bTextBlackOutline );`
`350`	`352`	`}`
`351`	`353`	`}`
`352`	`354`
`@@ -905,7 +907,7 @@ float CChat::GetTextExtent ( const char * szText, float fScale )`
`905`	`907`	`}`
`906`	`908`
`907`	`909`
`908`		`-void CChat::DrawTextString ( const char * szText, CRect2D DrawArea, float fZ, CRect2D ClipRect, unsigned long ulFormat, unsigned long ulColor, float fScaleX, float fScaleY, const CRect2D& RenderBounds )`
	`910`	`+void CChat::DrawTextString ( const char * szText, CRect2D DrawArea, float fZ, CRect2D ClipRect, unsigned long ulFormat, unsigned long ulColor, float fScaleX, float fScaleY, bool bOutline, const CRect2D& RenderBounds )`
`909`	`911`	`{`
`910`	`912`	`if ( !g_pChat )`
`911`	`913`	`return;`
`@@ -924,19 +926,19 @@ void CChat::DrawTextString ( const char * szText, CRect2D DrawArea, float fZ, CR`
`924`	`926`	`{`
`925`	`927`	`// Clip text at the top`
`926`	`928`	`if ( DrawArea.fY1 + fLineHeight - RenderBounds.fY1 > 1 )`
`927`		`- g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) RenderBounds.fY1, ( int ) DrawArea.fX2, ( int ) DrawArea.fY1 + fLineHeight, ulColor, szText, fScaleX, fScaleY, DT_LEFT \| DT_BOTTOM \| DT_SINGLELINE , g_pChat->m_pDXFont );`
	`929`	`+ g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) RenderBounds.fY1, ( int ) DrawArea.fX2, ( int ) DrawArea.fY1 + fLineHeight, ulColor, szText, fScaleX, fScaleY, DT_LEFT \| DT_BOTTOM \| DT_SINGLELINE , g_pChat->m_pDXFont, bOutline );`
`928`	`930`	`}`
`929`	`931`	`else`
`930`	`932`	`if ( DrawArea.fY1 + fLineHeight > RenderBounds.fY2 )`
`931`	`933`	`{`
`932`	`934`	`// Clip text at the bottom`
`933`	`935`	`if ( RenderBounds.fY2 - DrawArea.fY1 > 1 )`
`934`		`- g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX2, ( int ) RenderBounds.fY2, ulColor, szText, fScaleX, fScaleY, DT_LEFT \| DT_TOP \| DT_SINGLELINE , g_pChat->m_pDXFont );`
	`936`	`+ g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX2, ( int ) RenderBounds.fY2, ulColor, szText, fScaleX, fScaleY, DT_LEFT \| DT_TOP \| DT_SINGLELINE , g_pChat->m_pDXFont, bOutline );`
`935`	`937`	`}`
`936`	`938`	`else`
`937`	`939`	`{`
`938`	`940`	`// Text not clipped`
`939`		`- g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ulColor, szText, fScaleX, fScaleY, DT_LEFT \| DT_TOP \| DT_NOCLIP, g_pChat->m_pDXFont );`
	`941`	`+ g_pCore->GetGraphics ()->DrawString ( ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ( int ) DrawArea.fX1, ( int ) DrawArea.fY1, ulColor, szText, fScaleX, fScaleY, DT_LEFT \| DT_TOP \| DT_NOCLIP, g_pChat->m_pDXFont, bOutline );`
`940`	`942`	`}`
`941`	`943`	`}`
`942`	`944`	`}`
`@@ -1058,13 +1060,13 @@ const char* CChatLine::Format ( const char* szStringAnsi, float fWidth, CColor&`
`1058`	`1060`	`}`
`1059`	`1061`
`1060`	`1062`
`1061`		`-void CChatLine::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, const CRect2D& RenderBounds )`
	`1063`	`+void CChatLine::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline, const CRect2D& RenderBounds )`
`1062`	`1064`	`{`
`1063`	`1065`	`float fCurrentX = vecPosition.fX;`
`1064`	`1066`	`std::vector < CChatLineSection >::iterator iter = m_Sections.begin ();`
`1065`	`1067`	`for ( ; iter != m_Sections.end () ; iter++ )`
`1066`	`1068`	`{`
`1067`		`- (*iter).Draw ( CVector2D ( fCurrentX, vecPosition.fY ), ucAlpha, bShadow, RenderBounds );`
	`1069`	`+ (*iter).Draw ( CVector2D ( fCurrentX, vecPosition.fY ), ucAlpha, bShadow, bOutline, RenderBounds );`
`1068`	`1070`	`fCurrentX += (*iter).GetWidth ();`
`1069`	`1071`	`}`
`1070`	`1072`	`}`
`@@ -1082,27 +1084,27 @@ float CChatLine::GetWidth ()`
`1082`	`1084`	`}`
`1083`	`1085`
`1084`	`1086`
`1085`		`-void CChatInputLine::Draw ( CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow )`
	`1087`	`+void CChatInputLine::Draw ( CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline )`
`1086`	`1088`	`{`
`1087`	`1089`	`CRect2D RenderBounds ( 0, 0, 9999, 9999 );`
`1088`	`1090`
`1089`	`1091`	`CColor colPrefix;`
`1090`	`1092`	`m_Prefix.GetColor ( colPrefix );`
`1091`	`1093`	`if ( colPrefix.A > 0 )`
`1092`		`- m_Prefix.Draw ( vecPosition, colPrefix.A, bShadow, RenderBounds );`
	`1094`	`+ m_Prefix.Draw ( vecPosition, colPrefix.A, bShadow, bOutline, RenderBounds );`
`1093`	`1095`
`1094`	`1096`	`if ( g_pChat->m_InputTextColor.A > 0 && m_Sections.size () > 0 )`
`1095`	`1097`	`{`
`1096`	`1098`	`m_Sections [ 0 ].Draw ( CVector2D ( vecPosition.fX + m_Prefix.GetWidth (), vecPosition.fY ),`
`1097`		`- g_pChat->m_InputTextColor.A, bShadow, RenderBounds );`
	`1099`	`+ g_pChat->m_InputTextColor.A, bShadow, bOutline, RenderBounds );`
`1098`	`1100`
`1099`	`1101`	`float fLineDifference = CChat::GetFontHeight ( g_pChat->m_vecScale.fY );`
`1100`	`1102`
`1101`	`1103`	`vector < CChatLine >::iterator iter = m_ExtraLines.begin ();`
`1102`	`1104`	`for ( ; iter != m_ExtraLines.end () ; iter++ )`
`1103`	`1105`	`{`
`1104`	`1106`	`vecPosition.fY += fLineDifference;`
`1105`		`- (*iter).Draw ( vecPosition, g_pChat->m_InputTextColor.A, bShadow, RenderBounds );`
	`1107`	`+ (*iter).Draw ( vecPosition, g_pChat->m_InputTextColor.A, bShadow, bOutline, RenderBounds );`
`1106`	`1108`	`}`
`1107`	`1109`	`}`
`1108`	`1110`	`}`
`@@ -1134,17 +1136,17 @@ CChatLineSection& CChatLineSection::operator = ( const CChatLineSection& other )`
`1134`	`1136`	`return *this;`
`1135`	`1137`	`}`
`1136`	`1138`
`1137`		`-void CChatLineSection::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, const CRect2D& RenderBounds )`
	`1139`	`+void CChatLineSection::Draw ( const CVector2D& vecPosition, unsigned char ucAlpha, bool bShadow, bool bOutline, const CRect2D& RenderBounds )`
`1138`	`1140`	`{`
`1139`	`1141`	`if ( !m_strText.empty () && ucAlpha > 0 )`
`1140`	`1142`	`{`
`1141`	`1143`	`if ( bShadow )`
`1142`	`1144`	`{`
`1143`	`1145`	`CRect2D drawShadowAt ( vecPosition.fX + 1.0f, vecPosition.fY + 1.0f, vecPosition.fX + 1000.0f, vecPosition.fY + 1000.0f );`
`1144`		`- CChat::DrawTextString ( m_strText.c_str (), drawShadowAt, 0.0f, drawShadowAt, 0, COLOR_ARGB ( ucAlpha, 0, 0, 0 ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, RenderBounds );`
	`1146`	`+ CChat::DrawTextString ( m_strText.c_str (), drawShadowAt, 0.0f, drawShadowAt, 0, COLOR_ARGB ( ucAlpha, 0, 0, 0 ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, bOutline, RenderBounds );`
`1145`	`1147`	`}`
`1146`	`1148`	`CRect2D drawAt ( vecPosition.fX, vecPosition.fY, vecPosition.fX + 1000.0f, vecPosition.fY + 1000.0f );`
`1147`		`- CChat::DrawTextString ( m_strText.c_str (), drawAt, 0.0f, drawAt, 0, COLOR_ARGB ( ucAlpha, m_Color.R, m_Color.G, m_Color.B ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, RenderBounds );`
	`1149`	`+ CChat::DrawTextString ( m_strText.c_str (), drawAt, 0.0f, drawAt, 0, COLOR_ARGB ( ucAlpha, m_Color.R, m_Color.G, m_Color.B ), g_pChat->m_vecScale.fX, g_pChat->m_vecScale.fY, bOutline, RenderBounds );`
`1148`	`1150`	`}`
`1149`	`1151`	`}`
`1150`	`1152`