BVB Source Codes

CRYENGINE Show AIDebugDrawHelpers.cpp Source code

Return Download CRYENGINE: download AIDebugDrawHelpers.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   AIDebugDrawHelpers.cpp
  6.    $Id$
  7.    Description: Helper functions to draw some interesting debug shapes.
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 2006-9-19   : Created by Mikko Mononen
  12.  
  13.  *********************************************************************/
  14.  
  15. #include "StdAfx.h"
  16.  
  17. #include <math.h>
  18. #include <CryRenderer/IRenderer.h>
  19. #include <CryMath/Cry_Vector3.h>
  20. #include "AIDebugDrawHelpers.h"
  21.  
  22. static float g_drawOffset = 0.1f;
  23.  
  24. //====================================================================
  25. // DebugDrawCircleOutline
  26. //====================================================================
  27. void DebugDrawCircleOutline(IRenderer* pRend, const Vec3& pos, float rad, ColorB col)
  28. {
  29.         Vec3 points[20];
  30.  
  31.         for (unsigned i = 0; i < 20; i++)
  32.         {
  33.                 float a = ((float)i / 20.0f) * gf_PI2;
  34.                 points[i] = pos + Vec3(cosf(a) * rad, sinf(a) * rad, 0);
  35.         }
  36.         pRend->GetIRenderAuxGeom()->DrawPolyline(points, 20, true, col);
  37. }
  38.  
  39. //====================================================================
  40. // DebugDrawCapsuleOutline
  41. //====================================================================
  42. void DebugDrawCapsuleOutline(IRenderer* pRend, const Vec3& pos0, const Vec3& pos1, float rad, ColorB col)
  43. {
  44.         Vec3 points[20];
  45.         Vec3 axisy = pos1 - pos0;
  46.         axisy.Normalize();
  47.         Vec3 axisx(axisy.y, -axisy.x, 0);
  48.         axisx.Normalize();
  49.  
  50.         for (unsigned i = 0; i < 10; i++)
  51.         {
  52.                 float a = ((float)i / 9.0f) * gf_PI;
  53.                 points[i] = pos1 + axisx * cosf(a) * rad + axisy * sinf(a) * rad;
  54.         }
  55.  
  56.         for (unsigned i = 0; i < 10; i++)
  57.         {
  58.                 float a = gf_PI + ((float)i / 9.0f) * gf_PI;
  59.                 points[i + 10] = pos0 + axisx * cosf(a) * rad + axisy * sinf(a) * rad;
  60.         }
  61.  
  62.         pRend->GetIRenderAuxGeom()->DrawPolyline(points, 20, true, col);
  63. }
  64.  
  65. //====================================================================
  66. // DebugDrawWireSphere
  67. //====================================================================
  68. void DebugDrawWireSphere(IRenderer* pRend, const Vec3& pos, float rad, ColorB col)
  69. {
  70.         const unsigned npts = 32;
  71.         Vec3 xpoints[npts];
  72.         Vec3 ypoints[npts];
  73.         Vec3 zpoints[npts];
  74.  
  75.         for (unsigned i = 0; i < npts; i++)
  76.         {
  77.                 float a = ((float)i / (float)npts) * gf_PI2;
  78.                 float rx = cosf(a) * rad;
  79.                 float ry = sinf(a) * rad;
  80.                 xpoints[i] = pos + Vec3(rx, ry, 0);
  81.                 ypoints[i] = pos + Vec3(0, rx, ry);
  82.                 zpoints[i] = pos + Vec3(ry, 0, rx);
  83.         }
  84.         pRend->GetIRenderAuxGeom()->DrawPolyline(xpoints, npts, true, col);
  85.         pRend->GetIRenderAuxGeom()->DrawPolyline(ypoints, npts, true, col);
  86.         pRend->GetIRenderAuxGeom()->DrawPolyline(zpoints, npts, true, col);
  87. }
  88.  
  89. //====================================================================
  90. // DebugDrawWireFOVCone
  91. //====================================================================
  92. void DebugDrawWireFOVCone(IRenderer* pRend, const Vec3& pos, const Vec3& dir, float rad, float fov, ColorB col)
  93. {
  94.         const unsigned npts = 32;
  95.         const unsigned npts2 = 16;
  96.         Vec3 points[npts];
  97.         Vec3 pointsx[npts2];
  98.         Vec3 pointsy[npts2];
  99.  
  100.         Matrix33 base;
  101.         base.SetRotationVDir(dir);
  102.  
  103.         float coneRadius = sinf(fov) * rad;
  104.         float coneHeight = cosf(fov) * rad;
  105.  
  106.         for (unsigned i = 0; i < npts; i++)
  107.         {
  108.                 float a = ((float)i / (float)npts) * gf_PI2;
  109.                 float rx = cosf(a) * coneRadius;
  110.                 float ry = sinf(a) * coneRadius;
  111.                 points[i] = pos + base.TransformVector(Vec3(rx, coneHeight, ry));
  112.         }
  113.  
  114.         for (unsigned i = 0; i < npts2; i++)
  115.         {
  116.                 float a = -fov + ((float)i / (float)(npts2 - 1)) * (fov * 2);
  117.                 float rx = sinf(a) * rad;
  118.                 float ry = cosf(a) * rad;
  119.                 pointsx[i] = pos + base.TransformVector(Vec3(rx, ry, 0));
  120.                 pointsy[i] = pos + base.TransformVector(Vec3(0, ry, rx));
  121.         }
  122.  
  123.         pRend->GetIRenderAuxGeom()->DrawPolyline(points, npts, true, col);
  124.         pRend->GetIRenderAuxGeom()->DrawPolyline(pointsx, npts2, false, col);
  125.         pRend->GetIRenderAuxGeom()->DrawPolyline(pointsy, npts2, false, col);
  126.  
  127.         pRend->GetIRenderAuxGeom()->DrawLine(points[0], col, pos, col);
  128.         pRend->GetIRenderAuxGeom()->DrawLine(points[npts / 4], col, pos, col);
  129.         pRend->GetIRenderAuxGeom()->DrawLine(points[npts / 2], col, pos, col);
  130.         pRend->GetIRenderAuxGeom()->DrawLine(points[npts / 2 + npts / 4], col, pos, col);
  131. }
  132.  
  133. //====================================================================
  134. // DebugDrawArrow
  135. //====================================================================
  136. void DebugDrawArrow(IRenderer* pRend, const Vec3& pos, const Vec3& length, float width, ColorB col)
  137. {
  138.         Vec3 points[7];
  139.         Vec3 tris[5 * 3];
  140.  
  141.         float len = length.GetLength();
  142.         if (len < 0.0001f)
  143.                 return;
  144.  
  145.         float headLen = width * 2.0f;
  146.         float headWidth = width * 2.0f;
  147.  
  148.         if (headLen > len * 0.8f)
  149.                 headLen = len * 0.8f;
  150.  
  151.         Vec3 dir(length / len);
  152.         Vec3 norm(length.y, -length.x, 0);
  153.         norm.NormalizeSafe();
  154.  
  155.         Vec3 end(pos + length);
  156.         Vec3 start(pos);
  157.  
  158.         unsigned n = 0;
  159.         points[n++] = end;
  160.         points[n++] = end - dir * headLen - norm * headWidth / 2;
  161.         PREFAST_SUPPRESS_WARNING(6386)
  162.         points[n++] = end - dir * headLen - norm * width / 2;
  163.         points[n++] = end - dir * headLen + norm * width / 2;
  164.         points[n++] = end - dir * headLen + norm * headWidth / 2;
  165.         points[n++] = start - norm * width / 2;
  166.         points[n++] = start + norm * width / 2;
  167.  
  168.         // cppcheck-suppress redundantAssignment
  169.         n = 0;
  170.         tris[n++] = points[0];
  171.         tris[n++] = points[1];
  172.         tris[n++] = points[2];
  173.  
  174.         tris[n++] = points[0];
  175.         tris[n++] = points[2];
  176.         tris[n++] = points[3];
  177.  
  178.         tris[n++] = points[0];
  179.         tris[n++] = points[3];
  180.         tris[n++] = points[4];
  181.  
  182.         tris[n++] = points[2];
  183.         tris[n++] = points[5];
  184.         tris[n++] = points[6];
  185.  
  186.         tris[n++] = points[2];
  187.         tris[n++] = points[6];
  188.         tris[n++] = points[3];
  189.  
  190.         pRend->GetIRenderAuxGeom()->DrawTriangles(tris, n, col);
  191. }
  192.  
  193. //====================================================================
  194. // DebugDrawRangeCircle
  195. //====================================================================
  196. void DebugDrawRangeCircle(IRenderer* pRend, const Vec3& pos, float rad, float width,
  197.                           ColorB colFill, ColorB colOutline, bool drawOutline)
  198. {
  199.         const unsigned npts = 24;
  200.  
  201.         Vec3 points[npts];
  202.         Vec3 pointsOutline[npts];
  203.         Vec3 tris[npts * 2 * 3];
  204.  
  205.         if (width > rad) width = rad;
  206.  
  207.         for (unsigned i = 0; i < npts; i++)
  208.         {
  209.                 float a = ((float)i / (float)npts) * gf_PI2;
  210.                 points[i] = Vec3(cosf(a), sinf(a), 0);
  211.                 pointsOutline[i] = pos + points[i] * rad;
  212.         }
  213.  
  214.         unsigned n = 0;
  215.         for (unsigned i = 0; i < npts; i++)
  216.         {
  217.                 tris[n++] = pos + points[i] * (rad - width);
  218.                 tris[n++] = pos + points[i] * rad;
  219.                 tris[n++] = pos + points[(i + 1) % npts] * rad;
  220.  
  221.                 tris[n++] = pos + points[i] * (rad - width);
  222.                 tris[n++] = pos + points[(i + 1) % npts] * rad;
  223.                 tris[n++] = pos + points[(i + 1) % npts] * (rad - width);
  224.         }
  225.  
  226.         pRend->GetIRenderAuxGeom()->DrawTriangles(tris, npts * 2 * 3, colFill);
  227.         if (drawOutline)
  228.                 pRend->GetIRenderAuxGeom()->DrawPolyline(pointsOutline, npts, true, colOutline);
  229. }
  230.  
  231. //====================================================================
  232. // DebugDrawRangeArc
  233. //====================================================================
  234. void DebugDrawRangeArc(IRenderer* pRend, const Vec3& pos, const Vec3& dir, float angle, float rad, float width,
  235.                        ColorB colFill, ColorB colOutline, bool drawOutline)
  236. {
  237.         const unsigned npts = 12;
  238.  
  239.         Vec3 points[npts];
  240.         Vec3 pointsOutline[npts];
  241.         Vec3 tris[(npts - 1) * 2 * 3];
  242.  
  243.         Vec3 forw(dir.x, dir.y, 0.0f);
  244.         forw.NormalizeSafe();
  245.         Vec3 right(forw.y, -forw.x, 0);
  246.  
  247.         if (width > rad) width = rad;
  248.  
  249.         for (unsigned i = 0; i < npts; i++)
  250.         {
  251.                 float a = ((float)i / (float)(npts - 1) - 0.5f) * angle;
  252.                 points[i] = forw * cosf(a) + right * sinf(a);
  253.                 pointsOutline[i] = pos + points[i] * rad;
  254.         }
  255.  
  256.         unsigned n = 0;
  257.         for (unsigned i = 0; i < npts - 1; i++)
  258.         {
  259.                 tris[n++] = pos + points[i] * (rad - width);
  260.                 tris[n++] = pos + points[i + 1] * rad;
  261.                 tris[n++] = pos + points[i] * rad;
  262.  
  263.                 tris[n++] = pos + points[i] * (rad - width);
  264.                 tris[n++] = pos + points[i + 1] * (rad - width);
  265.                 tris[n++] = pos + points[i + 1] * rad;
  266.         }
  267.  
  268.         pRend->GetIRenderAuxGeom()->DrawTriangles(tris, n, colFill);
  269.         if (drawOutline)
  270.         {
  271.                 pRend->GetIRenderAuxGeom()->DrawPolyline(pointsOutline, npts, false, colOutline);
  272.                 pRend->GetIRenderAuxGeom()->DrawLine(pos + forw * (rad - width / 4), colOutline, pos + forw * (rad + width / 4), colOutline);
  273.         }
  274. }
  275.  
  276. //====================================================================
  277. // DebugDrawRange
  278. //====================================================================
  279. void DebugDrawRangeBox(IRenderer* pRend, const Vec3& pos, const Vec3& dir, float sizex, float sizey, float width,
  280.                        ColorB colFill, ColorB colOutline, bool drawOutline)
  281. {
  282.         float minX = sizex - width;
  283.         float maxX = sizex;
  284.         float minY = sizey - width;
  285.         float maxY = sizey;
  286.  
  287.         if (maxX < 0.001f || maxY < 0.001f || minX > maxX || minY > maxY)
  288.                 return;
  289.  
  290.         Vec3 points[8];
  291.         Vec3 tris[8 * 3];
  292.         Vec3 norm(dir.y, -dir.x, dir.z);
  293.  
  294.         points[0] = pos + norm * -minX + dir * -minY;
  295.         points[1] = pos + norm * minX + dir * -minY;
  296.         points[2] = pos + norm * minX + dir * minY;
  297.         points[3] = pos + norm * -minX + dir * minY;
  298.  
  299.         points[4] = pos + norm * -maxX + dir * -maxY;
  300.         points[5] = pos + norm * maxX + dir * -maxY;
  301.         points[6] = pos + norm * maxX + dir * maxY;
  302.         points[7] = pos + norm * -maxX + dir * maxY;
  303.  
  304.         unsigned n = 0;
  305.  
  306.         tris[n++] = points[0];
  307.         tris[n++] = points[5];
  308.         tris[n++] = points[1];
  309.         tris[n++] = points[0];
  310.         tris[n++] = points[4];
  311.         tris[n++] = points[5];
  312.  
  313.         tris[n++] = points[1];
  314.         tris[n++] = points[6];
  315.         tris[n++] = points[2];
  316.         tris[n++] = points[1];
  317.         tris[n++] = points[5];
  318.         tris[n++] = points[6];
  319.  
  320.         tris[n++] = points[2];
  321.         tris[n++] = points[7];
  322.         tris[n++] = points[3];
  323.         tris[n++] = points[2];
  324.         tris[n++] = points[6];
  325.         tris[n++] = points[7];
  326.  
  327.         tris[n++] = points[3];
  328.         tris[n++] = points[4];
  329.         tris[n++] = points[0];
  330.         tris[n++] = points[3];
  331.         tris[n++] = points[7];
  332.         tris[n++] = points[4];
  333.  
  334.         pRend->GetIRenderAuxGeom()->DrawTriangles(tris, 8 * 3, colFill);
  335.         if (drawOutline)
  336.                 pRend->GetIRenderAuxGeom()->DrawPolyline(&points[4], 4, true, colOutline);
  337. }
  338.  
  339. //====================================================================
  340. // DebugDrawRangePolygon
  341. //====================================================================
  342. template<typename containerType>
  343. void DebugDrawRangePolygon(IRenderer* pRend, const containerType& polygon, float width,
  344.                            ColorB colFill, ColorB colOutline, bool drawOutline)
  345. {
  346.         static std::vector<Vec3> verts;
  347.         static std::vector<vtx_idx> tris;
  348.         static std::vector<Vec3> outline;
  349.  
  350.         if (polygon.size() < 3) return;
  351.  
  352.         Vec3 prevDir(polygon.front() - polygon.back());
  353.         prevDir.NormalizeSafe();
  354.         Vec3 prevNorm(-prevDir.y, prevDir.x, 0.0f);
  355.         prevNorm.NormalizeSafe();
  356.         Vec3 prevPos(polygon.back());
  357.  
  358.         verts.clear();
  359.         outline.clear();
  360.  
  361.         typename containerType::const_iterator li, linext;
  362.         typename containerType::const_iterator liend = polygon.end();
  363.         for (li = polygon.begin(); li != liend; ++li)
  364.         {
  365.                 linext = li;
  366.                 ++linext;
  367.                 if (linext == liend)
  368.                         linext = polygon.begin();
  369.  
  370.                 const Vec3& curPos(*li);
  371.                 const Vec3& nextPos(*linext);
  372.                 Vec3 dir(nextPos - curPos);
  373.                 Vec3 norm(-dir.y, dir.x, 0.0f);
  374.                 norm.NormalizeSafe();
  375.  
  376.                 Vec3 mid((prevNorm + norm) * 0.5f);
  377.                 float dmr2 = sqr(mid.x) + sqr(mid.y);
  378.                 if (dmr2 > 0.00001f)
  379.                         mid *= 1.0f / dmr2;
  380.  
  381.                 float cross = prevDir.x * dir.y - dir.x * prevDir.y;
  382.  
  383.                 outline.push_back(curPos);
  384.  
  385.                 if (cross < 0.0f)
  386.                 {
  387.                         if (dmr2 * sqr(2.5f) < 1.0f)
  388.                         {
  389.                                 // bevel
  390.                                 verts.push_back(curPos);
  391.                                 verts.push_back(curPos + prevNorm * width);
  392.                                 verts.push_back(curPos);
  393.                                 verts.push_back(curPos + norm * width);
  394.                         }
  395.                         else
  396.                         {
  397.                                 verts.push_back(curPos);
  398.                                 verts.push_back(curPos + mid * width);
  399.                         }
  400.                 }
  401.                 else
  402.                 {
  403.                         verts.push_back(curPos);
  404.                         verts.push_back(curPos + mid * width);
  405.                 }
  406.  
  407.                 prevDir = dir;
  408.                 prevNorm = norm;
  409.                 prevPos = curPos;
  410.         }
  411.  
  412.         tris.clear();
  413.         size_t n = verts.size() / 2;
  414.         for (size_t i = 0; i < n; ++i)
  415.         {
  416.                 size_t j = (i + 1) % n;
  417.                 tris.push_back(i * 2);
  418.                 tris.push_back(j * 2);
  419.                 tris.push_back(j * 2 + 1);
  420.  
  421.                 tris.push_back(i * 2);
  422.                 tris.push_back(j * 2 + 1);
  423.                 tris.push_back(i * 2 + 1);
  424.         }
  425.  
  426.         pRend->GetIRenderAuxGeom()->DrawTriangles(&verts[0], verts.size(), &tris[0], tris.size(), colFill);
  427.  
  428.         if (drawOutline)
  429.                 pRend->GetIRenderAuxGeom()->DrawPolyline(&outline[0], outline.size(), true, colOutline);
  430. }
  431.  
  432. template
  433. void DebugDrawRangePolygon(IRenderer* pRend, const std::list<Vec3>& polygon, float width,
  434.                            ColorB colFill, ColorB colOutline, bool drawOutline);
  435.  
  436. template
  437. void DebugDrawRangePolygon(IRenderer* pRend, const std::vector<Vec3>& polygon, float width,
  438.                            ColorB colFill, ColorB colOutline, bool drawOutline);
  439.  
  440. //====================================================================
  441. // DebugDrawRangePolygon
  442. //====================================================================
  443. void DebugDrawLabel(IRenderer* pRenderer, int col, int row, const char* szText, float* pColor)
  444. {
  445.         float ColumnSize = 11;
  446.         float RowSize = 11;
  447.         float baseY = 10;
  448.         IRenderAuxText::Draw2dLabel(ColumnSize * static_cast<float>(col), baseY + RowSize * static_cast<float>(row), 1.2f, pColor, false, "%s", szText);
  449. }
  450.  
  451. //====================================================================
  452. // DebugDrawCircles
  453. //====================================================================
  454. void DebugDrawCircles(IRenderer* pRenderer, const Vec3& pos,
  455.                       float minRadius, float maxRadius, int numRings,
  456.                       const ColorF& insideCol, const ColorF& outsideCol)
  457. {
  458.         static int numPts = 32;
  459.         static std::vector<Vec3> unitCircle;
  460.         static bool init = false;
  461.  
  462.         if (init == false)
  463.         {
  464.                 init = true;
  465.                 unitCircle.reserve(numPts);
  466.                 for (int i = 0; i < numPts; ++i)
  467.                 {
  468.                         float angle = gf_PI2 * ((float) i) / numPts;
  469.                         unitCircle.push_back(Vec3(sinf(angle), cosf(angle), 0.0f));
  470.                 }
  471.         }
  472.         for (int iRing = 0; iRing < numRings; ++iRing)
  473.         {
  474.                 float ringFrac = 0.0f;
  475.                 if (numRings > 1)
  476.                         ringFrac += ((float) iRing) / (numRings - 1);
  477.  
  478.                 float radius = (1.0f - ringFrac) * minRadius + ringFrac * maxRadius;
  479.                 ColorF col = (1.0f - ringFrac) * insideCol + ringFrac * outsideCol;
  480.  
  481.                 Vec3 prevPt = pos + radius * unitCircle[numPts - 1];
  482.                 prevPt.z = GetDebugDrawZ(prevPt, true);
  483.                 for (int i = 0; i < numPts; ++i)
  484.                 {
  485.                         Vec3 pt = pos + radius * unitCircle[i];
  486.                         pt.z = GetDebugDrawZ(pt, true) + 0.05f;
  487.  
  488.                         pRenderer->GetIRenderAuxGeom()->DrawLine(prevPt, col, pt, col);
  489.                         prevPt = pt;
  490.                 }
  491.         }
  492. }
  493.  
  494. //====================================================================
  495. // DebugDrawEllipseOutline
  496. //====================================================================
  497. void DebugDrawEllipseOutline(IRenderer* pRend, const Vec3& pos, float radx, float rady, float orientation, ColorB col)
  498. {
  499.         Vec3 points[20];
  500.  
  501.         float sin_o = sinf(orientation);
  502.         float cos_o = cosf(orientation);
  503.         for (unsigned i = 0; i < 20; i++)
  504.         {
  505.                 float angle = ((float) i / 20.0f) * gf_PI2;
  506.                 float sin_a = sinf(angle);
  507.                 float cos_a = cosf(angle);
  508.                 float x = (cos_o * cos_a * radx) - (sin_o * sin_a * rady);
  509.                 float y = (cos_o * sin_a * rady) + (sin_o * cos_a * radx);
  510.                 points[i] = pos + Vec3(x, y, 0.0f);
  511.         }
  512.  
  513.         pRend->GetIRenderAuxGeom()->DrawPolyline(points, 20, true, col);
  514. }
  515.  
  516. //====================================================================
  517. // GetDebugDrawZ
  518. //====================================================================
  519. float GetDebugDrawZ(const Vec3& pt, bool useTerrain)
  520. {
  521.         if (useTerrain)
  522.         {
  523.                 if (gAIEnv.CVars.DebugDrawOffset <= 0.0f)
  524.                         return -gAIEnv.CVars.DebugDrawOffset;
  525.                 I3DEngine* pEngine = gEnv->p3DEngine;
  526.                 float terrainZ = pEngine->GetTerrainElevation(pt.x, pt.y);
  527.                 float waterZ = pEngine->GetWaterLevel(&pt);
  528.                 return max(terrainZ, waterZ) + gAIEnv.CVars.DebugDrawOffset;
  529.         }
  530.         else
  531.         {
  532.                 return pt.z + gAIEnv.CVars.DebugDrawOffset;
  533.         }
  534. }
  535.  
  536. //===================================================================
  537. // GetDebugCameraPos
  538. //===================================================================
  539. Vec3 GetDebugCameraPos()
  540. {
  541.         return gEnv->pSystem->GetViewCamera().GetPosition();
  542. }
  543.  
downloadAIDebugDrawHelpers.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