BVB Source Codes

CRYENGINE Show UIDraw.cpp Source code

Return Download CRYENGINE: download UIDraw.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: UI draw functions
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 07:11:2005: Created by Julien Darre
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15. #include "UIDraw.h"
  16.  
  17. //-----------------------------------------------------------------------------------------------------
  18.  
  19. CUIDraw::CUIDraw()
  20. {
  21.         m_pRenderer = gEnv->pRenderer;
  22. }
  23.  
  24. //-----------------------------------------------------------------------------------------------------
  25.  
  26. CUIDraw::~CUIDraw()
  27. {
  28.         for (TTexturesMap::iterator iter = m_texturesMap.begin(); iter != m_texturesMap.end(); ++iter)
  29.         {
  30.                 SAFE_RELEASE((*iter).second);
  31.         }
  32. }
  33.  
  34. //-----------------------------------------------------------------------------------------------------
  35.  
  36. void CUIDraw::Release()
  37. {
  38.         delete this;
  39. }
  40.  
  41. //-----------------------------------------------------------------------------------------------------
  42.  
  43. void CUIDraw::PreRender()
  44. {
  45.         m_pRenderer->SetCullMode(R_CULL_DISABLE);
  46.         m_pRenderer->Set2DMode(true, m_pRenderer->GetOverlayWidth(), m_pRenderer->GetOverlayHeight());
  47.         m_pRenderer->SetColorOp(eCO_MODULATE, eCO_MODULATE, DEF_TEXARG0, DEF_TEXARG0);
  48.         m_pRenderer->SetState(GS_BLSRC_SRCALPHA | GS_BLDST_ONEMINUSSRCALPHA | GS_NODEPTHTEST);
  49. }
  50.  
  51. //-----------------------------------------------------------------------------------------------------
  52.  
  53. void CUIDraw::PostRender()
  54. {
  55.         m_pRenderer->Set2DMode(false, 0, 0);
  56. }
  57.  
  58. //-----------------------------------------------------------------------------------------------------
  59.  
  60. uint32 CUIDraw::GetColorARGB(uint8 ucAlpha, uint8 ucRed, uint8 ucGreen, uint8 ucBlue)
  61. {
  62.         int iRGB = (m_pRenderer->GetFeatures() & RFT_RGBA);
  63.         return (iRGB ? RGBA8(ucRed, ucGreen, ucBlue, ucAlpha) : RGBA8(ucBlue, ucGreen, ucRed, ucAlpha));
  64. }
  65.  
  66. //-----------------------------------------------------------------------------------------------------
  67.  
  68. int CUIDraw::CreateTexture(const char* strName, bool dontRelease)
  69. {
  70.         for (TTexturesMap::iterator iter = m_texturesMap.begin(); iter != m_texturesMap.end(); ++iter)
  71.         {
  72.                 if (0 == strcmpi((*iter).second->GetName(), strName))
  73.                 {
  74.                         return (*iter).first;
  75.                 }
  76.         }
  77.         uint32 flags = FT_NOMIPS | FT_DONT_STREAM | FT_STATE_CLAMP;
  78.         if (dontRelease)
  79.         {
  80.                 GameWarning("Are you sure you want to permanently keep this UI texture '%s'?!", strName);
  81.         }
  82.  
  83.         flags |= dontRelease ? FT_DONT_RELEASE : 0;
  84.         ITexture* pTexture = m_pRenderer->EF_LoadTexture(strName, flags);
  85.         pTexture->SetClamp(true);
  86.         int iTextureID = pTexture->GetTextureID();
  87.         m_texturesMap.insert(std::make_pair(iTextureID, pTexture));
  88.         return iTextureID;
  89. }
  90.  
  91. //-----------------------------------------------------------------------------------------------------
  92.  
  93. bool CUIDraw::DeleteTexture(int iTextureID)
  94. {
  95.         TTexturesMap::iterator it = m_texturesMap.find(iTextureID);
  96.         if (it != m_texturesMap.end())
  97.         {
  98.                 m_texturesMap.erase(it);
  99.                 gEnv->pRenderer->RemoveTexture(iTextureID);
  100.                 return true;
  101.         }
  102.  
  103.         return false;
  104. }
  105.  
  106. //-----------------------------------------------------------------------------------------------------
  107.  
  108. void CUIDraw::GetTextureSize(int iTextureID, float& rfSizeX, float& rfSizeY)
  109. {
  110.         TTexturesMap::iterator Iter = m_texturesMap.find(iTextureID);
  111.         if (Iter != m_texturesMap.end())
  112.         {
  113.                 ITexture* pTexture = (*Iter).second;
  114.                 rfSizeX = (float) pTexture->GetWidth();
  115.                 rfSizeY = (float) pTexture->GetHeight();
  116.         }
  117.         else
  118.         {
  119.                 // Unknow texture !
  120.                 CRY_ASSERT(0);
  121.                 rfSizeX = 0.0f;
  122.                 rfSizeY = 0.0f;
  123.         }
  124. }
  125.  
  126. //-----------------------------------------------------------------------------------------------------
  127.  
  128. void CUIDraw::DrawLine(float fX1, float fY1, float fX2, float fY2, uint32 uiDiffuse)
  129. {
  130.         SVF_P3F_C4B_T2F aVertices[2];
  131.  
  132.         const float fOff = -0.5f;
  133.  
  134.         aVertices[0].color.dcolor = uiDiffuse;
  135.         aVertices[0].xyz = Vec3(fX1 + fOff, fY1 + fOff, 0.0f);
  136.         aVertices[0].st = Vec2(0, 0);
  137.  
  138.         aVertices[1].color.dcolor = uiDiffuse;
  139.         aVertices[1].xyz = Vec3(fX2 + fOff, fY2 + fOff, 0.0f);
  140.         aVertices[1].st = Vec2(1, 1);
  141.  
  142.         /*
  143.            if(iTextureID)
  144.            {
  145.             m_pRenderer->EnableTMU(true);
  146.             m_pRenderer->SetColorOp(eCO_MODULATE, eCO_MODULATE, DEF_TEXARG0, DEF_TEXARG0);
  147.             m_pRenderer->SetTexture(iTextureID);
  148.            }
  149.            else
  150.          */
  151.         {
  152.                 //m_pRenderer->EnableTMU(false);
  153.                 // m_pRenderer->SetWhiteTexture();
  154.         }
  155.  
  156.         uint16 ausIndices[] = { 0, 1 };
  157.  
  158.         m_pRenderer->DrawDynVB(aVertices, ausIndices, 2, 2, prtLineList);
  159.  
  160. }
  161.  
  162. //-----------------------------------------------------------------------------------------------------
  163.  
  164. void CUIDraw::DrawTriangle(float fX0, float fY0, float fX1, float fY1, float fX2, float fY2, uint32 uiColor)
  165. {
  166.         SVF_P3F_C4B_T2F aVertices[3];
  167.  
  168.         const float fOff = -0.5f;
  169.  
  170.         aVertices[0].color.dcolor = uiColor;
  171.         aVertices[0].xyz = Vec3(fX0 + fOff, fY0 + fOff, 0.0f);
  172.         aVertices[0].st = Vec2(0, 0);
  173.  
  174.         aVertices[1].color.dcolor = uiColor;
  175.         aVertices[1].xyz = Vec3(fX1 + fOff, fY1 + fOff, 0.0f);
  176.         aVertices[1].st = Vec2(0, 0);
  177.  
  178.         aVertices[2].color.dcolor = uiColor;
  179.         aVertices[2].xyz = Vec3(fX2 + fOff, fY2 + fOff, 0.0f);
  180.         aVertices[2].st = Vec2(0, 0);
  181.  
  182.         uint16 ausIndices[] = { 0, 1, 2 };
  183.  
  184.         m_pRenderer->SetWhiteTexture();
  185.         m_pRenderer->DrawDynVB(aVertices, ausIndices, 3, CRY_ARRAY_COUNT(ausIndices), prtTriangleList);
  186. }
  187.  
  188. //-----------------------------------------------------------------------------------------------------
  189.  
  190. void CUIDraw::DrawQuad(float fX,
  191.                        float fY,
  192.                        float fSizeX,
  193.                        float fSizeY,
  194.                        uint32 uiDiffuse,
  195.                        uint32 uiDiffuseTL,
  196.                        uint32 uiDiffuseTR,
  197.                        uint32 uiDiffuseDL,
  198.                        uint32 uiDiffuseDR,
  199.                        int iTextureID,
  200.                        float fUTexCoordsTL,
  201.                        float fVTexCoordsTL,
  202.                        float fUTexCoordsTR,
  203.                        float fVTexCoordsTR,
  204.                        float fUTexCoordsDL,
  205.                        float fVTexCoordsDL,
  206.                        float fUTexCoordsDR,
  207.                        float fVTexCoordsDR,
  208.                        bool bUse169)
  209. {
  210.         SVF_P3F_C4B_T2F aVertices[4];
  211.  
  212.         if (bUse169)
  213.         {
  214.                 float fWidth43 = m_pRenderer->GetHeight() * 4.0f / 3.0f;
  215.                 float fScale = fWidth43 / (float) m_pRenderer->GetWidth();
  216.                 float fOffset = (fSizeX - fSizeX * fScale);
  217.                 fX += 0.5f * fOffset;
  218.                 fSizeX -= fOffset;
  219.         }
  220.  
  221.         const float fOff = -0.5f;
  222.  
  223.         aVertices[0].color.dcolor = uiDiffuse ? uiDiffuse : uiDiffuseTL;
  224.         aVertices[0].xyz = Vec3(m_pRenderer->ScaleCoordX(fX) + fOff, m_pRenderer->ScaleCoordY(fY) + fOff, 0.0f);
  225.         aVertices[0].st = Vec2(fUTexCoordsTL, fVTexCoordsTL);
  226.  
  227.         aVertices[1].color.dcolor = uiDiffuse ? uiDiffuse : uiDiffuseTR;
  228.         aVertices[1].xyz = Vec3(m_pRenderer->ScaleCoordX(fX + fSizeX) + fOff, m_pRenderer->ScaleCoordY(fY) + fOff, 0.0f);
  229.         aVertices[1].st = Vec2(fUTexCoordsTR, fVTexCoordsTR);
  230.  
  231.         aVertices[2].color.dcolor = uiDiffuse ? uiDiffuse : uiDiffuseDL;
  232.         aVertices[2].xyz = Vec3(m_pRenderer->ScaleCoordX(fX) + fOff, m_pRenderer->ScaleCoordY(fY + fSizeY) + fOff, 0.0f);
  233.         aVertices[2].st = Vec2(fUTexCoordsDL, fVTexCoordsDL);
  234.  
  235.         aVertices[3].color.dcolor = uiDiffuse ? uiDiffuse : uiDiffuseDR;
  236.         aVertices[3].xyz = Vec3(m_pRenderer->ScaleCoordX(fX + fSizeX) + fOff, m_pRenderer->ScaleCoordY(fY + fSizeY) + fOff, 0.0f);
  237.         aVertices[3].st = Vec2(fUTexCoordsDR, fVTexCoordsDR);
  238.  
  239.         if (iTextureID >= 0)
  240.         {
  241.                 m_pRenderer->SetColorOp(eCO_MODULATE, eCO_MODULATE, DEF_TEXARG0, DEF_TEXARG0);
  242.                 m_pRenderer->SetTexture(iTextureID);
  243.         }
  244.         else
  245.         {
  246.                 //m_pRenderer->EnableTMU(false);
  247.                 // m_pRenderer->SetWhiteTexture();
  248.         }
  249.  
  250.         uint16 ausIndices[] = { 0, 1, 2, 3 };
  251.  
  252.         m_pRenderer->DrawDynVB(aVertices, ausIndices, 4, 4, prtTriangleStrip);
  253. }
  254.  
  255. //-----------------------------------------------------------------------------------------------------
  256.  
  257. void CUIDraw::DrawQuadSimple(float fX,
  258.                              float fY,
  259.                              float fSizeX,
  260.                              float fSizeY,
  261.                              uint32 uiDiffuse,
  262.                              int iTextureID)
  263. {
  264.         SVF_P3F_C4B_T2F aVertices[4];
  265.  
  266.         const float fOff = -0.5f;
  267.  
  268.         aVertices[0].color.dcolor = uiDiffuse;
  269.         aVertices[0].xyz = Vec3(fX + fOff, fY + fOff, 0.0f);
  270.         aVertices[0].st = Vec2(0, 0);
  271.  
  272.         aVertices[1].color.dcolor = uiDiffuse;
  273.         aVertices[1].xyz = Vec3(fX + fSizeX + fOff, fY + fOff, 0.0f);
  274.         aVertices[1].st = Vec2(1, 0);
  275.  
  276.         aVertices[2].color.dcolor = uiDiffuse;
  277.         aVertices[2].xyz = Vec3(fX + fOff, fY + fSizeY + fOff, 0.0f);
  278.         aVertices[2].st = Vec2(0, 1);
  279.  
  280.         aVertices[3].color.dcolor = uiDiffuse;
  281.         aVertices[3].xyz = Vec3(fX + fSizeX + fOff, fY + fSizeY + fOff, 0.0f);
  282.         aVertices[3].st = Vec2(1, 1);
  283.  
  284.         if (iTextureID)
  285.         {
  286.                 m_pRenderer->SetColorOp(eCO_MODULATE, eCO_MODULATE, DEF_TEXARG0, DEF_TEXARG0);
  287.                 m_pRenderer->SetTexture(iTextureID);
  288.         }
  289.         else
  290.         {
  291.                 //m_pRenderer->EnableTMU(false);
  292.                 // m_pRenderer->SetWhiteTexture();
  293.         }
  294.  
  295.         uint16 ausIndices[] = { 0, 1, 2, 3 };
  296.  
  297.         m_pRenderer->DrawDynVB(aVertices, ausIndices, 4, 4, prtTriangleStrip);
  298. }
  299.  
  300. //-----------------------------------------------------------------------------------------------------
  301.  
  302. void CUIDraw::DrawImage(int iTextureID, float fX,
  303.                         float fY,
  304.                         float fSizeX,
  305.                         float fSizeY,
  306.                         float fAngleInDegrees,
  307.                         float fRed,
  308.                         float fGreen,
  309.                         float fBlue,
  310.                         float fAlpha,
  311.                         float fS0,
  312.                         float fT0,
  313.                         float fS1,
  314.                         float fT1)
  315. {
  316.         float fWidth43 = m_pRenderer->GetHeight() * 4.0f / 3.0f;
  317.         float fScale = fWidth43 / (float) m_pRenderer->GetWidth();
  318.         float fOffset = (fSizeX - fSizeX * fScale);
  319.         fX += 0.5f * fOffset;
  320.         fSizeX -= fOffset;
  321.  
  322.         m_pRenderer->Draw2dImage(fX,
  323.                                  fY + fSizeY,
  324.                                  fSizeX,
  325.                                  -fSizeY,
  326.                                  iTextureID,
  327.                                  fS0, fT0, fS1, fT1,
  328.                                  fAngleInDegrees,
  329.                                  fRed,
  330.                                  fGreen,
  331.                                  fBlue,
  332.                                  fAlpha);
  333. }
  334.  
  335. //-----------------------------------------------------------------------------------------------------
  336.  
  337. void CUIDraw::DrawImageCentered(int iTextureID, float fX,
  338.                                 float fY,
  339.                                 float fSizeX,
  340.                                 float fSizeY,
  341.                                 float fAngleInDegrees,
  342.                                 float fRed,
  343.                                 float fGreen,
  344.                                 float fBlue,
  345.                                 float fAlpha)
  346. {
  347.         float fImageX = fX - 0.5f * fSizeX;
  348.         float fImageY = fY - 0.5f * fSizeY;
  349.  
  350.         DrawImage(iTextureID, fImageX, fImageY, fSizeX, fSizeY, fAngleInDegrees, fRed, fGreen, fBlue, fAlpha);
  351. }
  352.  
  353. //-----------------------------------------------------------------------------------------------------
  354.  
  355. void CUIDraw::DrawTextSimple(IFFont* pFont,
  356.                              float fX, float fY,
  357.                              float fSizeX, float fSizeY,
  358.                              const char* strText, ColorF color,
  359.                              EUIDRAWHORIZONTAL eUIDrawHorizontal, EUIDRAWVERTICAL eUIDrawVertical)
  360. {
  361.         InternalDrawText(pFont, fX, fY, 0.0f,
  362.                          fSizeX, fSizeY,
  363.                          strText,
  364.                          color.a, color.r, color.g, color.b,
  365.                          UIDRAWHORIZONTAL_LEFT, UIDRAWVERTICAL_TOP, eUIDrawHorizontal, eUIDrawVertical);
  366. }
  367.  
  368. //-----------------------------------------------------------------------------------------------------
  369.  
  370. void CUIDraw::DrawText(IFFont* pFont,
  371.                        float fX,
  372.                        float fY,
  373.                        float fSizeX,
  374.                        float fSizeY,
  375.                        const char* strText,
  376.                        float fAlpha,
  377.                        float fRed,
  378.                        float fGreen,
  379.                        float fBlue,
  380.                        EUIDRAWHORIZONTAL eUIDrawHorizontalDocking,
  381.                        EUIDRAWVERTICAL eUIDrawVerticalDocking,
  382.                        EUIDRAWHORIZONTAL eUIDrawHorizontal,
  383.                        EUIDRAWVERTICAL eUIDrawVertical)
  384. {
  385.         InternalDrawText(pFont, fX, fY, 0.0f,
  386.                          fSizeX, fSizeY,
  387.                          strText,
  388.                          fAlpha, fRed, fGreen, fBlue,
  389.                          eUIDrawHorizontalDocking, eUIDrawVerticalDocking, eUIDrawHorizontal, eUIDrawVertical);
  390. }
  391.  
  392. void CUIDraw::DrawWrappedText(IFFont* pFont,
  393.                               float fX,
  394.                               float fY,
  395.                               float fMaxWidth,
  396.                               float fSizeX,
  397.                               float fSizeY,
  398.                               const char* strText,
  399.                               float fAlpha,
  400.                               float fRed,
  401.                               float fGreen,
  402.                               float fBlue,
  403.                               EUIDRAWHORIZONTAL eUIDrawHorizontalDocking,
  404.                               EUIDRAWVERTICAL eUIDrawVerticalDocking,
  405.                               EUIDRAWHORIZONTAL eUIDrawHorizontal,
  406.                               EUIDRAWVERTICAL eUIDrawVertical
  407.                               )
  408. {
  409.         InternalDrawText(pFont, fX, fY, fMaxWidth,
  410.                          fSizeX, fSizeY,
  411.                          strText,
  412.                          fAlpha, fRed, fGreen, fBlue,
  413.                          eUIDrawHorizontalDocking, eUIDrawVerticalDocking, eUIDrawHorizontal, eUIDrawVertical);
  414. }
  415.  
  416. //-----------------------------------------------------------------------------------------------------
  417.  
  418. void CUIDraw::InternalDrawText(IFFont* pFont,
  419.                                float fX,
  420.                                float fY,
  421.                                float fMaxWidth,
  422.                                float fSizeX,
  423.                                float fSizeY,
  424.                                const char* strText,
  425.                                float fAlpha,
  426.                                float fRed,
  427.                                float fGreen,
  428.                                float fBlue,
  429.                                EUIDRAWHORIZONTAL eUIDrawHorizontalDocking,
  430.                                EUIDRAWVERTICAL eUIDrawVerticalDocking,
  431.                                EUIDRAWHORIZONTAL eUIDrawHorizontal,
  432.                                EUIDRAWVERTICAL eUIDrawVertical
  433.                                )
  434. {
  435.         if (NULL == pFont)
  436.         {
  437.                 return;
  438.         }
  439.  
  440.         const bool bWrapText = fMaxWidth > 0.0f;
  441.         if (bWrapText)
  442.                 fMaxWidth = m_pRenderer->ScaleCoordX(fMaxWidth);
  443.  
  444.         //      fSizeX = m_pRenderer->ScaleCoordX(fSizeX);
  445.         //      fSizeY = m_pRenderer->ScaleCoordY(fSizeY);
  446.  
  447.         // Note: First ScaleCoordY is not a mistake
  448.         if (fSizeX <= 0.0f) fSizeX = 15.0f;
  449.         if (fSizeY <= 0.0f) fSizeY = 15.0f;
  450.  
  451.         fSizeX = m_pRenderer->ScaleCoordY(fSizeX);
  452.         fSizeY = m_pRenderer->ScaleCoordY(fSizeY);
  453.  
  454.         STextDrawContext ctx;
  455.         ctx.SetSizeIn800x600(false);
  456.         ctx.SetSize(Vec2(fSizeX, fSizeY));
  457.         ctx.SetColor(ColorF(fRed, fGreen, fBlue, fAlpha));
  458.  
  459.         // Note: First ScaleCoordY is not a mistake
  460.  
  461.         float fTextX = m_pRenderer->ScaleCoordY(fX);
  462.         float fTextY = m_pRenderer->ScaleCoordY(fY);
  463.  
  464.         if (UIDRAWHORIZONTAL_CENTER == eUIDrawHorizontalDocking)
  465.         {
  466.                 fTextX += m_pRenderer->GetWidth() * 0.5f;
  467.         }
  468.         else if (UIDRAWHORIZONTAL_RIGHT == eUIDrawHorizontalDocking)
  469.         {
  470.                 fTextX += m_pRenderer->GetWidth();
  471.         }
  472.  
  473.         if (UIDRAWVERTICAL_CENTER == eUIDrawVerticalDocking)
  474.         {
  475.                 fTextY += m_pRenderer->GetHeight() * 0.5f;
  476.         }
  477.         else if (UIDRAWVERTICAL_BOTTOM == eUIDrawVerticalDocking)
  478.         {
  479.                 fTextY += m_pRenderer->GetHeight();
  480.         }
  481.  
  482.         string wrappedStr;
  483.         if (bWrapText)
  484.         {
  485.                 pFont->WrapText(wrappedStr, fMaxWidth, strText, ctx);
  486.                 strText = wrappedStr.c_str();
  487.         }
  488.  
  489.         Vec2 vDim = pFont->GetTextSize(strText, true, ctx);
  490.         int flags = 0;
  491.  
  492.         if (UIDRAWHORIZONTAL_CENTER == eUIDrawHorizontal)
  493.         {
  494.                 fTextX -= vDim.x * 0.5f;
  495.                 flags |= eDrawText_Center;
  496.         }
  497.         else if (UIDRAWHORIZONTAL_RIGHT == eUIDrawHorizontal)
  498.         {
  499.                 fTextX -= vDim.x;
  500.                 flags |= eDrawText_Right;
  501.         }
  502.  
  503.         if (UIDRAWVERTICAL_CENTER == eUIDrawVertical)
  504.         {
  505.                 fTextY -= vDim.y * 0.5f;
  506.                 flags |= eDrawText_CenterV;
  507.         }
  508.         else if (UIDRAWVERTICAL_BOTTOM == eUIDrawVertical)
  509.         {
  510.                 fTextY -= vDim.y;
  511.                 flags |= eDrawText_Bottom;
  512.         }
  513.  
  514.         ctx.SetFlags(flags);
  515.  
  516.         pFont->DrawString(fTextX, fTextY, strText, true, ctx);
  517. }
  518.  
  519. //-----------------------------------------------------------------------------------------------------
  520.  
  521. void CUIDraw::InternalGetTextDim(IFFont* pFont,
  522.                                  float* fWidth,
  523.                                  float* fHeight,
  524.                                  float fMaxWidth,
  525.                                  float fSizeX,
  526.                                  float fSizeY,
  527.                                  const char* strText)
  528. {
  529.         if (NULL == pFont)
  530.         {
  531.                 return;
  532.         }
  533.  
  534.         const bool bWrapText = fMaxWidth > 0.0f;
  535.         if (bWrapText)
  536.                 fMaxWidth = m_pRenderer->ScaleCoordX(fMaxWidth);
  537.  
  538.         //      fSizeX = m_pRenderer->ScaleCoordX(fSizeX);
  539.         //      fSizeY = m_pRenderer->ScaleCoordY(fSizeY);
  540.  
  541.         // Note: First ScaleCoordY is not a mistake
  542.         if (fSizeX <= 0.0f) fSizeX = 15.0f;
  543.         if (fSizeY <= 0.0f) fSizeY = 15.0f;
  544.  
  545.         fSizeX = m_pRenderer->ScaleCoordY(fSizeX);
  546.         fSizeY = m_pRenderer->ScaleCoordY(fSizeY);
  547.  
  548.         STextDrawContext ctx;
  549.         ctx.SetSizeIn800x600(false);
  550.         ctx.SetSize(Vec2(fSizeX, fSizeY));
  551.  
  552.         string wrappedStr;
  553.         if (bWrapText)
  554.         {
  555.                 pFont->WrapText(wrappedStr, fMaxWidth, strText, ctx);
  556.                 strText = wrappedStr.c_str();
  557.         }
  558.  
  559.         Vec2 dim = pFont->GetTextSize(strText, true, ctx);
  560.  
  561.         float fScaleBack = 1.0f / m_pRenderer->ScaleCoordY(1.0f);
  562.         if (fWidth)
  563.                 *fWidth = dim.x * fScaleBack;
  564.         if (fHeight)
  565.                 *fHeight = dim.y * fScaleBack;
  566. }
  567.  
  568. //-----------------------------------------------------------------------------------------------------
  569.  
  570. void CUIDraw::GetTextDim(IFFont* pFont,
  571.                          float* fWidth,
  572.                          float* fHeight,
  573.                          float fSizeX,
  574.                          float fSizeY,
  575.                          const char* strText)
  576. {
  577.         InternalGetTextDim(pFont, fWidth, fHeight, 0.0f, fSizeX, fSizeY, strText);
  578. }
  579.  
  580. void CUIDraw::GetWrappedTextDim(IFFont* pFont,
  581.                                 float* fWidth,
  582.                                 float* fHeight,
  583.                                 float fMaxWidth,
  584.                                 float fSizeX,
  585.                                 float fSizeY,
  586.                                 const char* strText)
  587. {
  588.         InternalGetTextDim(pFont, fWidth, fHeight, fMaxWidth, fSizeX, fSizeY, strText);
  589. }
  590.  
  591. //-----------------------------------------------------------------------------------------------------
  592.  
  593. void CUIDraw::GetMemoryStatistics(ICrySizer* s)
  594. {
  595.         SIZER_SUBCOMPONENT_NAME(s, "UIDraw");
  596.         s->Add(*this);
  597.         s->AddContainer(m_texturesMap);
  598. }
  599.  
  600. //-----------------------------------------------------------------------------------------------------
  601.  
downloadUIDraw.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top