BVB Source Codes

CRYENGINE Show AIDebugRenderer.cpp Source code

Return Download CRYENGINE: download AIDebugRenderer.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "AIDebugRenderer.h"
  5.  
  6. #include <math.h>
  7. #include <CryRenderer/IRenderer.h>
  8. #include <CryMath/Cry_Vector3.h>
  9.  
  10. CAIDebugRenderer::CAIDebugRenderer(IRenderer* pRenderer)
  11.         : m_pRenderer(pRenderer)
  12. {
  13.         m_pRenderAuxGeom = gEnv->pAuxGeomRenderer;
  14. }
  15.  
  16. //===================================================================
  17. // GetCameraPos
  18. //===================================================================
  19. Vec3 CAIDebugRenderer::GetCameraPos()
  20. {
  21.         return gEnv->pSystem->GetViewCamera().GetPosition();
  22. }
  23.  
  24. //====================================================================
  25. // GetDebugDrawZ
  26. //====================================================================
  27. float CAIDebugRenderer::GetDebugDrawZ(const Vec3& vPoint, bool bUseTerrainOrWater)
  28. {
  29.         const float g_drawOffset = 0.1f;
  30.  
  31.         if (bUseTerrainOrWater)
  32.         {
  33.                 if (g_drawOffset <= 0.0f)
  34.                         return -g_drawOffset;
  35.                 I3DEngine* pEngine = gEnv->p3DEngine;
  36.                 float terrainZ = pEngine->GetTerrainElevation(vPoint.x, vPoint.y);
  37.                 float waterZ = pEngine->GetWaterLevel(&vPoint);
  38.                 return max(terrainZ, waterZ) + g_drawOffset;
  39.         }
  40.         else
  41.                 return vPoint.z + g_drawOffset;
  42. }
  43.  
  44. void CAIDebugRenderer::DrawAABB(const AABB& aabb, bool bSolid, const ColorB& color, const EBoundingBoxDrawStyle& bbDrawStyle)
  45. {
  46.         m_pRenderAuxGeom->DrawAABB(aabb, bSolid, color, bbDrawStyle);
  47. }
  48.  
  49. void CAIDebugRenderer::DrawAABB(const AABB& aabb, const Matrix34& matWorld, bool bSolid, const ColorB& color, const EBoundingBoxDrawStyle& bbDrawStyle)
  50. {
  51.         m_pRenderAuxGeom->DrawAABB(aabb, matWorld, bSolid, color, bbDrawStyle);
  52. }
  53.  
  54. //====================================================================
  55. // DebugDrawArrow
  56. //====================================================================
  57. void CAIDebugRenderer::DrawArrow(const Vec3& vPos, const Vec3& vLength, float fWidth, const ColorB& color)
  58. {
  59.         Vec3 points[7];
  60.         Vec3 tris[5 * 3];
  61.  
  62.         float len = vLength.GetLength();
  63.         if (len < 0.0001f)
  64.                 return;
  65.  
  66.         float headLen = fWidth * 2.0f;
  67.         float headWidth = fWidth * 2.0f;
  68.  
  69.         if (headLen > len * 0.8f)
  70.                 headLen = len * 0.8f;
  71.  
  72.         Vec3 vDir(vLength / len);
  73.         Vec3 norm(vLength.y, -vLength.x, 0);
  74.         norm.NormalizeSafe();
  75.  
  76.         Vec3 end(vPos + vLength);
  77.         Vec3 start(vPos);
  78.  
  79.         unsigned int n = 0;
  80.         points[n++] = end;
  81.         points[n++] = end - vDir * headLen - norm * headWidth / 2;
  82.         PREFAST_SUPPRESS_WARNING(6386)
  83.         points[n++] = end - vDir * headLen - norm * fWidth / 2;
  84.         points[n++] = end - vDir * headLen + norm * fWidth / 2;
  85.         points[n++] = end - vDir * headLen + norm * headWidth / 2;
  86.         points[n++] = start - norm * fWidth / 2;
  87.         points[n++] = start + norm * fWidth / 2;
  88.  
  89.         // cppcheck-suppress redundantAssignment
  90.         n = 0;
  91.         tris[n++] = points[0];
  92.         tris[n++] = points[1];
  93.         tris[n++] = points[2];
  94.  
  95.         tris[n++] = points[0];
  96.         tris[n++] = points[2];
  97.         tris[n++] = points[3];
  98.  
  99.         tris[n++] = points[0];
  100.         tris[n++] = points[3];
  101.         tris[n++] = points[4];
  102.  
  103.         tris[n++] = points[2];
  104.         tris[n++] = points[5];
  105.         tris[n++] = points[6];
  106.  
  107.         tris[n++] = points[2];
  108.         tris[n++] = points[6];
  109.         tris[n++] = points[3];
  110.  
  111.         DrawTriangles(tris, n, color);
  112. }
  113.  
  114. //====================================================================
  115. // DebugDrawCapsuleOutline
  116. //====================================================================
  117. void CAIDebugRenderer::DrawCapsuleOutline(const Vec3& vPos0, const Vec3& vPos1, float fRadius, const ColorB& color)
  118. {
  119.         Vec3 points[20];
  120.         Vec3 axisy = vPos1 - vPos0;
  121.         axisy.Normalize();
  122.         Vec3 axisx(axisy.y, -axisy.x, 0);
  123.         axisx.Normalize();
  124.  
  125.         for (unsigned int i = 0; i < 10; i++)
  126.         {
  127.                 float a = ((float)i / 9.0f) * gf_PI;
  128.                 points[i] = vPos1 + axisx * cosf(a) * fRadius + axisy * sinf(a) * fRadius;
  129.         }
  130.  
  131.         for (unsigned int i = 0; i < 10; i++)
  132.         {
  133.                 float a = gf_PI + ((float)i / 9.0f) * gf_PI;
  134.                 points[i + 10] = vPos0 + axisx * cosf(a) * fRadius + axisy * sinf(a) * fRadius;
  135.         }
  136.  
  137.         DrawPolyline(points, 20, true, color);
  138. }
  139.  
  140. //====================================================================
  141. // DebugDrawCircleOutline
  142. //====================================================================
  143. void CAIDebugRenderer::DrawCircleOutline(const Vec3& vPos, float fRadius, const ColorB& color)
  144. {
  145.         Vec3 points[20];
  146.  
  147.         for (unsigned int i = 0; i < 20; i++)
  148.         {
  149.                 float a = ((float)i / 20.0f) * gf_PI2;
  150.                 points[i] = vPos + Vec3(cosf(a) * fRadius, sinf(a) * fRadius, 0);
  151.         }
  152.         DrawPolyline(points, 20, true, color);
  153. }
  154.  
  155. //====================================================================
  156. // DebugDrawCircles
  157. //====================================================================
  158. void CAIDebugRenderer::DrawCircles(const Vec3& vPos,
  159.                                    float fMinRadius, float fMaxRadius, int numRings,
  160.                                    const ColorF& vInsideColor, const ColorF& vOutsideColor)
  161. {
  162.         static int numPts = 32;
  163.         static std::vector<Vec3> unitCircle;
  164.         static bool init = false;
  165.  
  166.         if (init == false)
  167.         {
  168.                 init = true;
  169.                 unitCircle.reserve(numPts);
  170.                 for (int i = 0; i < numPts; ++i)
  171.                 {
  172.                         float angle = gf_PI2 * ((float)i) / numPts;
  173.                         unitCircle.push_back(Vec3(sinf(angle), cosf(angle), 0.0f));
  174.                 }
  175.         }
  176.  
  177.         for (int iRing = 0; iRing < numRings; ++iRing)
  178.         {
  179.                 float ringFrac = 0.0f;
  180.                 if (numRings > 1)
  181.                         ringFrac += ((float)iRing) / (numRings - 1);
  182.  
  183.                 float fRadius = (1.0f - ringFrac) * fMinRadius + ringFrac * fMaxRadius;
  184.                 ColorF col = (1.0f - ringFrac) * vInsideColor + ringFrac * vOutsideColor;
  185.  
  186.                 Vec3 prevPt = vPos + fRadius * unitCircle[numPts - 1];
  187.                 prevPt.z = GetDebugDrawZ(prevPt, true);
  188.                 for (int i = 0; i < numPts; ++i)
  189.                 {
  190.                         Vec3 pt = vPos + fRadius * unitCircle[i];
  191.                         pt.z = GetDebugDrawZ(pt, true) + 0.05f;
  192.  
  193.                         DrawLine(prevPt, col, pt, col);
  194.                         prevPt = pt;
  195.                 }
  196.         }
  197. }
  198.  
  199. void CAIDebugRenderer::DrawCone(const Vec3& vPos, const Vec3& vDir, float fRadius, float fHeight, const ColorB& color, bool fDrawShaded)
  200. {
  201.         m_pRenderAuxGeom->DrawCone(vPos, vDir, fRadius, fHeight, color, fDrawShaded);
  202. }
  203.  
  204. void CAIDebugRenderer::DrawCylinder(const Vec3& vPos, const Vec3& vDir, float fRadius, float fHeight, const ColorB& color, bool bDrawShaded)
  205. {
  206.         m_pRenderAuxGeom->DrawCylinder(vPos, vDir, fRadius, fHeight, color, bDrawShaded);
  207. }
  208.  
  209. //====================================================================
  210. // DebugDrawEllipseOutline
  211. //====================================================================
  212. void CAIDebugRenderer::DrawEllipseOutline(const Vec3& vPos, float fRadiusX, float fRadiusY, float fOrientation, const ColorB& color)
  213. {
  214.         Vec3 points[20];
  215.  
  216.         float sin_o = sinf(fOrientation);
  217.         float cos_o = cosf(fOrientation);
  218.         for (unsigned int i = 0; i < 20; i++)
  219.         {
  220.                 float angle = ((float)i / 20.0f) * gf_PI2;
  221.                 float sin_a = sinf(angle);
  222.                 float cos_a = cosf(angle);
  223.                 float x = (cos_o * cos_a * fRadiusX) - (sin_o * sin_a * fRadiusY);
  224.                 float y = (cos_o * sin_a * fRadiusY) + (sin_o * cos_a * fRadiusX);
  225.                 points[i] = vPos + Vec3(x, y, 0.0f);
  226.         }
  227.  
  228.         DrawPolyline(points, 20, true, color);
  229. }
  230.  
  231. //====================================================================
  232. // DebugDrawLabel
  233. //====================================================================
  234. void CAIDebugRenderer::Draw2dLabel(int nCol, int nRow, const char* szText, const ColorB& color)
  235. {
  236.         float ColumnSize = 11;
  237.         float RowSize = 11;
  238.         float baseY = 10;
  239.         float p_fColor[4] = {
  240.                 color.r / 255.0f,
  241.                 color.g / 255.0f,
  242.                 color.b / 255.0f,
  243.                 color.a / 255.0f
  244.         };
  245.  
  246.         IRenderAuxText::Draw2dLabel(ColumnSize * static_cast<float>(nCol), baseY + RowSize * static_cast<float>(nRow), 1.2f, p_fColor, false, "%s", szText);
  247. }
  248.  
  249. void CAIDebugRenderer::Draw2dLabel(float fX, float fY, float fFontSize, const ColorB& color, bool bCenter, const char* text, ...)
  250. {
  251.         va_list args;
  252.         va_start(args, text);
  253.         IRenderAuxText::DrawText(Vec3(fX, fY, 0.5f), fFontSize, color, eDrawText_IgnoreOverscan | eDrawText_2D | eDrawText_800x600 | eDrawText_FixedSize | eDrawText_Monospace | (bCenter ? eDrawText_Center : 0), text, args);
  254.         va_end(args);
  255. }
  256.  
  257. void CAIDebugRenderer::Draw2dLabelEx(float fX, float fY, float fFontSize, const ColorB& color, bool bFixedSize, bool bMonospace, bool bCenter, bool bFramed, const char* text, ...)
  258. {
  259.         va_list args;
  260.         va_start(args, text);
  261.  
  262.         int flags = eDrawText_IgnoreOverscan | eDrawText_2D | eDrawText_800x600
  263.                    | (bFixedSize ? eDrawText_FixedSize : 0)
  264.                    | (bMonospace ? eDrawText_Monospace : 0)
  265.                    | (bFramed ? eDrawText_Framed : 0)
  266.                    | (bCenter ? eDrawText_Center : 0);
  267.  
  268.         IRenderAuxText::DrawText(Vec3(fX, fY, 0.5f), fFontSize, color, flags, text, args);
  269.  
  270.         va_end(args);
  271. }
  272.  
  273. void CAIDebugRenderer::Draw3dLabel(Vec3 vPos, float fFontSize, const char* text, ...)
  274. {
  275.         va_list args;
  276.         va_start(args, text);
  277.         IRenderAuxText::DrawText(vPos, fFontSize, NULL, eDrawText_FixedSize | eDrawText_800x600, text, args);
  278.         va_end(args);
  279. }
  280.  
  281. void CAIDebugRenderer::Draw3dLabelEx(Vec3 vPos, float fFontSize, const ColorB& color, bool bFixedSize, bool bCenter, bool bDepthTest, bool bFramed, const char* text, ...)
  282. {
  283.         va_list args;
  284.         va_start(args, text);
  285.  
  286.         int flags = (bFramed ? eDrawText_Framed : 0) | (bDepthTest ? eDrawText_DepthTest : 0) | (bFixedSize ? eDrawText_FixedSize : 0) | (bCenter ? eDrawText_Center : 0) | eDrawText_800x600;
  287.  
  288.         IRenderAuxText::DrawText(vPos, fFontSize, color, flags, text, args);
  289.  
  290.         va_end(args);
  291. }
  292.  
  293. void CAIDebugRenderer::DrawLabel(Vec3 pos, SDrawTextInfo& ti, const char* text)
  294. {
  295.         IRenderAuxText::DrawText(pos, ti, text);
  296. }
  297.  
  298. void CAIDebugRenderer::Draw2dImage(float fX, float fY, float fWidth, float fHeight, int nTextureID, float fS0, float fT0, float fS1, float fT1, float fAngle, float fR, float fG, float fB, float fA, float fZ)
  299. {
  300.         if (m_pRenderer)
  301.         {
  302.                 m_pRenderer->Draw2dImage(fX, fY, fWidth, fHeight, nTextureID, fS0, fT0, fS1, fT1, fAngle, fR, fG, fB, fA, fZ);
  303.         }
  304. }
  305.  
  306. void CAIDebugRenderer::DrawLine(const Vec3& v0, const ColorB& colorV0, const Vec3& v1, const ColorB& colorV1, float thickness)
  307. {
  308.         m_pRenderAuxGeom->DrawLine(v0, colorV0, v1, colorV1, thickness);
  309. }
  310.  
  311. void CAIDebugRenderer::DrawOBB(const OBB& obb, const Vec3& vPos, bool bSolid, const ColorB& color, const EBoundingBoxDrawStyle bbDrawStyle)
  312. {
  313.         m_pRenderAuxGeom->DrawOBB(obb, vPos, bSolid, color, bbDrawStyle);
  314. }
  315.  
  316. void CAIDebugRenderer::DrawOBB(const OBB& obb, const Matrix34& matWorld, bool bSolid, const ColorB& color, const EBoundingBoxDrawStyle bbDrawStyle)
  317. {
  318.         m_pRenderAuxGeom->DrawOBB(obb, matWorld, bSolid, color, bbDrawStyle);
  319. }
  320.  
  321. void CAIDebugRenderer::DrawPolyline(const Vec3* va, uint32 nPoints, bool bClosed, const ColorB& color, float fThickness)
  322. {
  323.         m_pRenderAuxGeom->DrawPolyline(va, nPoints, bClosed, color, fThickness);
  324. }
  325.  
  326. void CAIDebugRenderer::DrawPolyline(const Vec3* va, uint32 nPoints, bool bClosed, const ColorB* colorArray, float fThickness)
  327. {
  328.         m_pRenderAuxGeom->DrawPolyline(va, nPoints, bClosed, colorArray, fThickness);
  329. }
  330.  
  331. //====================================================================
  332. // DebugDrawRangeArc
  333. //====================================================================
  334. void CAIDebugRenderer::DrawRangeArc(const Vec3& vPos, const Vec3& vDir, float fAngle, float fRadius, float fWidth,
  335.                                     const ColorB& colorFill, const ColorB& colorOutline, bool bDrawOutline)
  336. {
  337.         const unsigned npts = 12;
  338.  
  339.         Vec3 points[npts];
  340.         Vec3 pointsOutline[npts];
  341.         Vec3 tris[(npts - 1) * 2 * 3];
  342.  
  343.         Vec3 forw(vDir.x, vDir.y, 0.0f);
  344.         forw.NormalizeSafe();
  345.         Vec3 right(forw.y, -forw.x, 0);
  346.  
  347.         if (fWidth > fRadius) fWidth = fRadius;
  348.  
  349.         for (unsigned int i = 0; i < npts; i++)
  350.         {
  351.                 float a = ((float)i / (float)(npts - 1) - 0.5f) * fAngle;
  352.                 points[i] = forw * cosf(a) + right * sinf(a);
  353.                 pointsOutline[i] = vPos + points[i] * fRadius;
  354.         }
  355.  
  356.         unsigned int n = 0;
  357.         for (unsigned int i = 0; i < npts - 1; i++)
  358.         {
  359.                 tris[n++] = vPos + points[i] * (fRadius - fWidth);
  360.                 tris[n++] = vPos + points[i + 1] * fRadius;
  361.                 tris[n++] = vPos + points[i] * fRadius;
  362.  
  363.                 tris[n++] = vPos + points[i] * (fRadius - fWidth);
  364.                 tris[n++] = vPos + points[i + 1] * (fRadius - fWidth);
  365.                 tris[n++] = vPos + points[i + 1] * fRadius;
  366.         }
  367.  
  368.         DrawTriangles(tris, n, colorFill);
  369.         if (bDrawOutline)
  370.         {
  371.                 DrawPolyline(pointsOutline, npts, false, colorOutline);
  372.                 DrawLine(vPos + forw * (fRadius - fWidth / 4), colorOutline, vPos + forw * (fRadius + fWidth / 4), colorOutline);
  373.         }
  374. }
  375.  
  376. //====================================================================
  377. // DebugDrawRange
  378. //====================================================================
  379. void CAIDebugRenderer::DrawRangeBox(const Vec3& vPos, const Vec3& vDir, float fSizeX, float fSizeY, float fWidth,
  380.                                     const ColorB& colorFill, const ColorB& colorOutline, bool bDrawOutline)
  381. {
  382.         float minX = fSizeX - fWidth;
  383.         float maxX = fSizeX;
  384.         float minY = fSizeY - fWidth;
  385.         float maxY = fSizeY;
  386.  
  387.         if (maxX < 0.001f || maxY < 0.001f || minX > maxX || minY > maxY)
  388.                 return;
  389.  
  390.         Vec3 points[8];
  391.         Vec3 tris[8 * 3];
  392.         Vec3 norm(vDir.y, -vDir.x, vDir.z);
  393.  
  394.         points[0] = vPos + norm * -minX + vDir * -minY;
  395.         points[1] = vPos + norm * minX + vDir * -minY;
  396.         points[2] = vPos + norm * minX + vDir * minY;
  397.         points[3] = vPos + norm * -minX + vDir * minY;
  398.  
  399.         points[4] = vPos + norm * -maxX + vDir * -maxY;
  400.         points[5] = vPos + norm * maxX + vDir * -maxY;
  401.         points[6] = vPos + norm * maxX + vDir * maxY;
  402.         points[7] = vPos + norm * -maxX + vDir * maxY;
  403.  
  404.         unsigned int n = 0;
  405.  
  406.         tris[n++] = points[0];
  407.         tris[n++] = points[5];
  408.         tris[n++] = points[1];
  409.         tris[n++] = points[0];
  410.         tris[n++] = points[4];
  411.         tris[n++] = points[5];
  412.  
  413.         tris[n++] = points[1];
  414.         tris[n++] = points[6];
  415.         tris[n++] = points[2];
  416.         tris[n++] = points[1];
  417.         tris[n++] = points[5];
  418.         tris[n++] = points[6];
  419.  
  420.         tris[n++] = points[2];
  421.         tris[n++] = points[7];
  422.         tris[n++] = points[3];
  423.         tris[n++] = points[2];
  424.         tris[n++] = points[6];
  425.         tris[n++] = points[7];
  426.  
  427.         tris[n++] = points[3];
  428.         tris[n++] = points[4];
  429.         tris[n++] = points[0];
  430.         tris[n++] = points[3];
  431.         tris[n++] = points[7];
  432.         tris[n++] = points[4];
  433.  
  434.         DrawTriangles(tris, 8 * 3, colorFill);
  435.         if (bDrawOutline)
  436.                 DrawPolyline(&points[4], 4, true, colorOutline);
  437. }
  438.  
  439. //====================================================================
  440. // DebugDrawRangeCircle
  441. //====================================================================
  442. void CAIDebugRenderer::DrawRangeCircle(const Vec3& vPos, float fRadius, float fWidth,
  443.                                        const ColorB& colorFill, const ColorB& colorOutline, bool bDrawOutline)
  444. {
  445.         const unsigned npts = 24;
  446.  
  447.         Vec3 points[npts];
  448.         Vec3 pointsOutline[npts];
  449.         Vec3 tris[npts * 2 * 3];
  450.  
  451.         if (fWidth > fRadius) fWidth = fRadius;
  452.  
  453.         for (unsigned int i = 0; i < npts; i++)
  454.         {
  455.                 float a = ((float)i / (float)npts) * gf_PI2;
  456.                 points[i] = Vec3(cosf(a), sinf(a), 0);
  457.                 pointsOutline[i] = vPos + points[i] * fRadius;
  458.         }
  459.  
  460.         unsigned int n = 0;
  461.         for (unsigned int i = 0; i < npts; i++)
  462.         {
  463.                 tris[n++] = vPos + points[i] * (fRadius - fWidth);
  464.                 tris[n++] = vPos + points[i] * fRadius;
  465.                 tris[n++] = vPos + points[(i + 1) % npts] * fRadius;
  466.  
  467.                 tris[n++] = vPos + points[i] * (fRadius - fWidth);
  468.                 tris[n++] = vPos + points[(i + 1) % npts] * fRadius;
  469.                 tris[n++] = vPos + points[(i + 1) % npts] * (fRadius - fWidth);
  470.         }
  471.  
  472.         DrawTriangles(tris, npts * 2 * 3, colorFill);
  473.         if (bDrawOutline)
  474.                 DrawPolyline(pointsOutline, npts, true, colorOutline);
  475. }
  476.  
  477. //====================================================================
  478. // DebugDrawRangePolygon
  479. //====================================================================
  480. void CAIDebugRenderer::DrawRangePolygon(const Vec3 polygon[], int nVertices, float fWidth,
  481.                                         const ColorB& colorFill, const ColorB& colorOutline, bool bDrawOutline)
  482. {
  483.         static std::vector<Vec3> verts;
  484.         static std::vector<vtx_idx> tris;
  485.         static std::vector<Vec3> outline;
  486.  
  487.         if (nVertices < 3) return;
  488.  
  489.         Vec3 prevDir(polygon[0] - polygon[nVertices - 1]);
  490.         prevDir.NormalizeSafe();
  491.         Vec3 prevNorm(-prevDir.y, prevDir.x, 0.0f);
  492.         prevNorm.NormalizeSafe();
  493.         Vec3 prevPos(polygon[nVertices - 1]);
  494.  
  495.         verts.clear();
  496.         outline.clear();
  497.  
  498.         const Vec3* li, * linext;
  499.         const Vec3* liend = polygon + nVertices;
  500.         for (li = polygon; li != liend; ++li)
  501.         {
  502.                 linext = li;
  503.                 ++linext;
  504.                 if (linext == liend)
  505.                         linext = polygon;
  506.  
  507.                 const Vec3& curPos(*li);
  508.                 const Vec3& nextPos(*linext);
  509.                 Vec3 vDir(nextPos - curPos);
  510.                 Vec3 norm(-vDir.y, vDir.x, 0.0f);
  511.                 norm.NormalizeSafe();
  512.  
  513.                 Vec3 mid((prevNorm + norm) * 0.5f);
  514.                 float dmr2 = sqr(mid.x) + sqr(mid.y);
  515.                 if (dmr2 > 0.00001f)
  516.                         mid *= 1.0f / dmr2;
  517.  
  518.                 float cross = prevDir.x * vDir.y - vDir.x * prevDir.y;
  519.  
  520.                 outline.push_back(curPos);
  521.  
  522.                 if (cross < 0.0f)
  523.                 {
  524.                         if (dmr2 * sqr(2.5f) < 1.0f)
  525.                         {
  526.                                 // bevel
  527.                                 verts.push_back(curPos);
  528.                                 verts.push_back(curPos + prevNorm * fWidth);
  529.                                 verts.push_back(curPos);
  530.                                 verts.push_back(curPos + norm * fWidth);
  531.                         }
  532.                         else
  533.                         {
  534.                                 verts.push_back(curPos);
  535.                                 verts.push_back(curPos + mid * fWidth);
  536.                         }
  537.                 }
  538.                 else
  539.                 {
  540.                         verts.push_back(curPos);
  541.                         verts.push_back(curPos + mid * fWidth);
  542.                 }
  543.  
  544.                 prevDir = vDir;
  545.                 prevNorm = norm;
  546.                 prevPos = curPos;
  547.         }
  548.  
  549.         tris.clear();
  550.         size_t n = verts.size() / 2;
  551.         for (size_t i = 0; i < n; ++i)
  552.         {
  553.                 size_t j = (i + 1) % n;
  554.                 tris.push_back(i * 2);
  555.                 tris.push_back(j * 2);
  556.                 tris.push_back(j * 2 + 1);
  557.  
  558.                 tris.push_back(i * 2);
  559.                 tris.push_back(j * 2 + 1);
  560.                 tris.push_back(i * 2 + 1);
  561.         }
  562.  
  563.         m_pRenderAuxGeom->DrawTriangles(&verts[0], verts.size(), &tris[0], tris.size(), colorFill);
  564.         if (bDrawOutline)
  565.                 DrawPolyline(&outline[0], outline.size(), true, colorOutline);
  566. }
  567.  
  568. void CAIDebugRenderer::DrawSphere(const Vec3& vPos, float fRadius, const ColorB& color, bool bDrawShaded)
  569. {
  570.         m_pRenderAuxGeom->DrawSphere(vPos, fRadius, color, bDrawShaded);
  571. }
  572.  
  573. void CAIDebugRenderer::DrawTriangle(const Vec3& v0, const ColorB& colorV0, const Vec3& v1, const ColorB& colorV1, const Vec3& v2, const ColorB& colorV2)
  574. {
  575.         m_pRenderAuxGeom->DrawTriangle(v0, colorV0, v1, colorV1, v2, colorV2);
  576. }
  577.  
  578. void CAIDebugRenderer::DrawTriangles(const Vec3* va, unsigned int numPoints, const ColorB& color)
  579. {
  580.         m_pRenderAuxGeom->DrawTriangles(va, numPoints, color);
  581. }
  582.  
  583. //====================================================================
  584. // DebugDrawWireFOVCone
  585. //====================================================================
  586. void CAIDebugRenderer::DrawWireFOVCone(const Vec3& vPos, const Vec3& vDir, float fRadius, float fFOV, const ColorB& color)
  587. {
  588.         const unsigned int npts = 32;
  589.         const unsigned int npts2 = 16;
  590.         Vec3 points[npts];
  591.         Vec3 pointsx[npts2];
  592.         Vec3 pointsy[npts2];
  593.  
  594.         Matrix33 base;
  595.         base.SetRotationVDir(vDir);
  596.  
  597.         float coneRadius = sinf(fFOV) * fRadius;
  598.         float coneHeight = cosf(fFOV) * fRadius;
  599.  
  600.         for (unsigned int i = 0; i < npts; i++)
  601.         {
  602.                 float a = ((float)i / (float)npts) * gf_PI2;
  603.                 float rx = cosf(a) * coneRadius;
  604.                 float ry = sinf(a) * coneRadius;
  605.                 points[i] = vPos + base.TransformVector(Vec3(rx, coneHeight, ry));
  606.         }
  607.  
  608.         for (unsigned int i = 0; i < npts2; i++)
  609.         {
  610.                 float a = -fFOV + ((float)i / (float)(npts2 - 1)) * (fFOV * 2);
  611.                 float rx = sinf(a) * fRadius;
  612.                 float ry = cosf(a) * fRadius;
  613.                 pointsx[i] = vPos + base.TransformVector(Vec3(rx, ry, 0));
  614.                 pointsy[i] = vPos + base.TransformVector(Vec3(0, ry, rx));
  615.         }
  616.  
  617.         DrawPolyline(points, npts, true, color);
  618.         DrawPolyline(pointsx, npts2, false, color);
  619.         DrawPolyline(pointsy, npts2, false, color);
  620.  
  621.         DrawLine(points[0], color, vPos, color);
  622.         DrawLine(points[npts / 4], color, vPos, color);
  623.         DrawLine(points[npts / 2], color, vPos, color);
  624.         DrawLine(points[npts / 2 + npts / 4], color, vPos, color);
  625. }
  626.  
  627. //====================================================================
  628. // DebugDrawWireSphere
  629. //====================================================================
  630. void CAIDebugRenderer::DrawWireSphere(const Vec3& vPos, float fRadius, const ColorB& color)
  631. {
  632.         const unsigned int npts = 32;
  633.         Vec3 xpoints[npts];
  634.         Vec3 ypoints[npts];
  635.         Vec3 zpoints[npts];
  636.  
  637.         for (unsigned int i = 0; i < npts; i++)
  638.         {
  639.                 float a = ((float)i / (float)npts) * gf_PI2;
  640.                 float rx = cosf(a) * fRadius;
  641.                 float ry = sinf(a) * fRadius;
  642.                 xpoints[i] = vPos + Vec3(rx, ry, 0);
  643.                 ypoints[i] = vPos + Vec3(0, rx, ry);
  644.                 zpoints[i] = vPos + Vec3(ry, 0, rx);
  645.         }
  646.  
  647.         DrawPolyline(xpoints, npts, true, color);
  648.         DrawPolyline(ypoints, npts, true, color);
  649.         DrawPolyline(zpoints, npts, true, color);
  650. }
  651.  
  652. ITexture* CAIDebugRenderer::LoadTexture(const char* sNameOfTexture, uint32 nFlags)
  653. {
  654.         return m_pRenderer ? m_pRenderer->EF_LoadTexture(sNameOfTexture, nFlags) : nullptr;
  655. }
  656.  
  657. // [9/16/2010 evgeny] ProjectToScreen is not guaranteed to work if used outside Renderer
  658. bool CAIDebugRenderer::ProjectToScreen(float fInX, float fInY, float fInZ, float* fOutX, float* fOutY, float* fOutZ)
  659. {
  660.         return m_pRenderer ? m_pRenderer->ProjectToScreen(fInX, fInY, fInZ, fOutX, fOutY, fOutZ) : false;
  661. }
  662.  
  663. void CAIDebugRenderer::TextToScreen(float fX, float fY, const char* format, ...)
  664. {
  665.         // Copy-pasted from Renderer.cpp
  666.         char buffer[512];
  667.         va_list args;
  668.         va_start(args, format);
  669.         cry_vsprintf(buffer, format, args);
  670.         va_end(args);
  671.  
  672.         IRenderAuxText::TextToScreen(fX, fY, buffer);
  673. }
  674.  
  675. void CAIDebugRenderer::TextToScreenColor(int nX, int nY, float fRed, float fGreen, float fBlue, float fAlpha, const char* format, ...)
  676. {
  677.         // Copy-pasted from Renderer.cpp
  678.         char buffer[512];
  679.         va_list args;
  680.         va_start(args, format);
  681.         cry_vsprintf(buffer, format, args);
  682.         va_end(args);
  683.  
  684.         IRenderAuxText::TextToScreenColor(nX, nY, fRed, fGreen, fBlue, fAlpha, buffer);
  685. }
  686.  
  687. void CAIDebugRenderer::Init2DMode()
  688. {
  689.         m_pRenderAuxGeom->SetRenderFlags(SAuxGeomRenderFlags(e_Def2DPublicRenderflags));
  690. }
  691.  
  692. void CAIDebugRenderer::Init3DMode()
  693. {
  694.         m_pRenderAuxGeom->SetRenderFlags(SAuxGeomRenderFlags(e_Def3DPublicRenderflags));
  695. }
  696.  
  697. void CAIDebugRenderer::SetAlphaBlended(bool bOn)
  698. {
  699.         IRenderAuxGeom* pRenderAuxGeom = m_pRenderAuxGeom;
  700.         SAuxGeomRenderFlags flags = pRenderAuxGeom->GetRenderFlags();
  701.         flags.SetAlphaBlendMode(bOn ? e_AlphaBlended : e_AlphaNone);
  702.         pRenderAuxGeom->SetRenderFlags(flags);
  703. }
  704.  
  705. void CAIDebugRenderer::SetBackFaceCulling(bool bOn)
  706. {
  707.         IRenderAuxGeom* pRenderAuxGeom = m_pRenderAuxGeom;
  708.         SAuxGeomRenderFlags flags = pRenderAuxGeom->GetRenderFlags();
  709.         flags.SetCullMode(bOn ? e_CullModeBack : e_CullModeNone);
  710.         pRenderAuxGeom->SetRenderFlags(flags);
  711. }
  712.  
  713. void CAIDebugRenderer::SetDepthTest(bool bOn)
  714. {
  715.         IRenderAuxGeom* pRenderAuxGeom = m_pRenderAuxGeom;
  716.         SAuxGeomRenderFlags flags = pRenderAuxGeom->GetRenderFlags();
  717.         flags.SetDepthTestFlag(bOn ? e_DepthTestOn : e_DepthTestOff);
  718.         pRenderAuxGeom->SetRenderFlags(flags);
  719. }
  720.  
  721. void CAIDebugRenderer::SetDepthWrite(bool bOn)
  722. {
  723.         IRenderAuxGeom* pRenderAuxGeom = m_pRenderAuxGeom;
  724.         SAuxGeomRenderFlags flags = pRenderAuxGeom->GetRenderFlags();
  725.         flags.SetDepthWriteFlag(bOn ? e_DepthWriteOn : e_DepthWriteOff);
  726.         pRenderAuxGeom->SetRenderFlags(flags);
  727. }
  728.  
  729. void CAIDebugRenderer::SetDrawInFront(bool bOn)
  730. {
  731.         IRenderAuxGeom* pRenderAuxGeom = m_pRenderAuxGeom;
  732.         SAuxGeomRenderFlags flags = pRenderAuxGeom->GetRenderFlags();
  733.         flags.SetDrawInFrontMode(bOn ? e_DrawInFrontOn : e_DrawInFrontOff);
  734.         pRenderAuxGeom->SetRenderFlags(flags);
  735. }
  736.  
  737. void CAIDebugRenderer::SetMaterialColor(float fRed, float fGreen, float fBlue, float fAlpha)
  738. {
  739.         if (m_pRenderer)
  740.         {
  741.                 m_pRenderer->SetMaterialColor(fRed, fGreen, fBlue, fAlpha);
  742.         }
  743. }
  744.  
  745. unsigned int CAIDebugRenderer::PopState()
  746. {
  747.         if (m_pRenderAuxGeom)
  748.         {
  749.                 m_pRenderAuxGeom->SetRenderFlags(m_FlagsStack.top());
  750.         }
  751.         m_FlagsStack.pop();
  752.         return m_FlagsStack.size();
  753. }
  754.  
  755. unsigned int CAIDebugRenderer::PushState()
  756. {
  757.         m_FlagsStack.push(m_pRenderAuxGeom ?
  758.                           m_pRenderAuxGeom->GetRenderFlags() : SAuxGeomRenderFlags());
  759.         return m_FlagsStack.size();
  760. }
  761.  
downloadAIDebugRenderer.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