BVB Source Codes

CRYENGINE Show ParticleDebug.cpp Source code

Return Download CRYENGINE: download ParticleDebug.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  Created:     06/02/2015 by Filipe amim
  5. //  Description:
  6. // -------------------------------------------------------------------------
  7. //
  8. ////////////////////////////////////////////////////////////////////////////
  9.  
  10. #include "StdAfx.h"
  11. #include <CryMath/FinalizingSpline.h>
  12. #include "ParticleCommon.h"
  13. #include "ParticleDebug.h"
  14. #include "ParticleContainer.h"
  15. #include "ParticleComponent.h"
  16. #include "ParticleComponentRuntime.h"
  17. #include "ParticleEffect.h"
  18. #include "ParticleEmitter.h"
  19. #include "Features/FeatureCollision.h"
  20.  
  21. CRY_PFX2_DBG
  22.  
  23. namespace pfx2
  24. {
  25.  
  26. namespace
  27. {
  28.  
  29. const ColorB black(0, 0, 0);
  30. const ColorB white(255, 255, 255);
  31. const ColorF whiteF(1.0f, 1.0f, 1.0f);
  32. const ColorB lightOrange(255, 198, 128);
  33. const ColorB red(192, 23, 32);
  34. const ColorB darkRed(96, 0, 0);
  35.  
  36. const float startPos = 1.0f / 40.0f;
  37. const float barSz = 1.0f / 192.0f;
  38. const float barGap = 1.0f / 24.0f;
  39.  
  40. void DebugDrawEffect(CParticleEffect* pEffect, size_t effectBarIdx)
  41. {
  42. #if 0
  43.         // emitter bars
  44.         IRenderer* pRender = gEnv->pRenderer;
  45.         IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
  46.         Vec2 screenSz = Vec2(float(gEnv->pRenderer->GetWidth()), float(gEnv->pRenderer->GetHeight()));
  47.  
  48.         size_t numEmitters = pEffect->GetEmitterCount();
  49.         Vec2 pixSz = Vec2(1.0f / gEnv->pRenderer->GetWidth(), 1.0f / gEnv->pRenderer->GetHeight());
  50.         const Vec2 emitterSz = Vec2(barSz, 0.9f / numEmitters);
  51.         const Vec2 emitterLoc = Vec2(effectBarIdx * barGap + startPos, startPos);
  52.  
  53.         Vec3 pos = Vec2(effectBarIdx * barGap + startPos, startPos);
  54.         for (size_t i = 0; i < numEmitters; ++i)
  55.         {
  56.                 AABB box;
  57.                 box.min = pos;
  58.                 box.max.x = box.min.x + MAX(emitterSz.x, pixSz.x);
  59.                 box.max.y = box.min.y + MAX(emitterSz.y - pixSz.y, pixSz.y);
  60.                 ColorB color = pEffect->GetEmitter(i).m_active ? red : darkRed;
  61.                 pRenderAux->DrawAABB(box, true, color, eBBD_Faceted);
  62.                 pos.y += emitterSz.y;
  63.         }
  64.  
  65.         pRender->Draw2dLabel(
  66.           screenSz.x * (effectBarIdx * barGap + startPos),
  67.           screenSz.y * 0.975f, 1.0f, whiteF, false,
  68.           pEffect->GetName());
  69. #endif
  70. }
  71.  
  72. void DebugDrawComponentRuntime(CParticleComponentRuntime* pRuntime, size_t emitterBarIdx, size_t barIdx)
  73. {
  74.         IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
  75.         SAuxGeomRenderFlags prevFlags = pRenderAux->GetRenderFlags();
  76.         SAuxGeomRenderFlags curFlags = prevFlags;
  77.         Vec2 screenSz = Vec2(float(gEnv->pRenderer->GetWidth()), float(gEnv->pRenderer->GetHeight()));
  78.         curFlags.SetMode2D3DFlag(e_Mode2D);
  79.         curFlags.SetDepthTestFlag(e_DepthTestOff);
  80.         curFlags.SetDepthWriteFlag(e_DepthWriteOff);
  81.         pRenderAux->SetRenderFlags(curFlags);
  82.  
  83.         const SUpdateContext context = SUpdateContext(pRuntime);
  84.         const CParticleContainer& container = context.m_container;
  85.         const SComponentParams& params = context.m_params;
  86.         const size_t numInstances = pRuntime->GetNumInstances();
  87.         IPidStream parentIds = container.GetIPidStream(EPDT_ParentId);
  88.         TIStream<uint8> states = container.GetTIStream<uint8>(EPDT_State);
  89.         IFStream normAges = container.GetIFStream(EPDT_NormalAge);
  90.         const Vec2 pixSz = Vec2(1.0f / gEnv->pRenderer->GetWidth(), 1.0f / gEnv->pRenderer->GetHeight());
  91.         const Vec2 partSz = Vec2(barSz, 0.9f / container.GetMaxParticles());
  92.         const Vec2 contLoc = Vec2(barIdx * barGap + barSz * 3.0f + startPos, startPos);
  93.         const float off = barSz * 0.5f;
  94.         Vec2 pos;
  95.  
  96.         // instance bars
  97.         if (numInstances)
  98.         {
  99.                 const Vec2 instSz = Vec2(barSz, 0.9f / numInstances);
  100.                 const Vec2 instLoc = Vec2(barIdx * barGap + startPos, startPos);
  101.                 pos = instLoc;
  102.                 for (size_t i = 0; i < numInstances; ++i)
  103.                 {
  104.                         AABB box;
  105.                         box.min = pos;
  106.                         box.max.x = box.min.x + MAX(instSz.x, pixSz.x);
  107.                         box.max.y = box.min.y + MAX(instSz.y - pixSz.y, pixSz.y);
  108.                         ColorF color = ColorF(0.0f, 0.5f, 1.0f);
  109.                         pRenderAux->DrawAABB(box, true, ColorB(color), eBBD_Faceted);
  110.                         pos.y += instSz.y;
  111.                 }
  112.         }
  113.  
  114.         // particle bars
  115.         pos = contLoc;
  116.         CRY_PFX2_FOR_ACTIVE_PARTICLES(context)
  117.         {
  118.                 AABB box;
  119.                 // box.min = pos;
  120.                 box.min.x = contLoc.x;
  121.                 box.min.y = contLoc.y + partSz.y * particleId;
  122.                 box.max.x = box.min.x + MAX(partSz.x, pixSz.x);
  123.                 box.max.y = box.min.y + MAX(partSz.y - pixSz.y, pixSz.y);
  124.                 ColorB color = black;
  125.                 const uint8 state = states.Load(particleId);
  126.                 const float age = normAges.Load(particleId);
  127.                 if (state == ES_Alive)
  128.                         color = ColorB(ColorF(age, 1.0f - age, 0.0f));
  129.                 pRenderAux->DrawAABB(box, true, color, eBBD_Faceted);
  130.         }
  131.         CRY_PFX2_FOR_END;
  132.  
  133.         if (params.IsSecondGen())
  134.         {
  135.                 const CParticleContainer& parentContainer = pRuntime->GetParentContainer();
  136.                 const Vec2 parentPartSz = Vec2(barSz, 0.9f / parentContainer.GetMaxParticles());
  137.                 const Vec2 parentContLoc = Vec2((emitterBarIdx + params.m_parentId) * barGap + barSz * 3.0f + startPos, startPos);
  138.  
  139.                 // parenting lines
  140.                 CRY_PFX2_FOR_ACTIVE_PARTICLES(context)
  141.                 {
  142.                         const TParticleId parentId = parentIds.Load(particleId);
  143.                         if (parentId == gInvalidId)
  144.                                 continue;
  145.                         Vec2 from = contLoc + partSz * 0.5f + Vec2(-off, partSz.y * particleId);
  146.                         Vec2 to = parentContLoc + parentPartSz * 0.5f + Vec2(off, parentPartSz.y * parentId);
  147.                         pRenderAux->DrawLine(from, lightOrange, to, black, 1.0f);
  148.                 }
  149.                 CRY_PFX2_FOR_END;
  150.         }
  151.  
  152.         IRenderAuxText::Draw2dLabel(
  153.           screenSz.x * (barIdx * barGap + startPos),
  154.           screenSz.y * 0.95f, 1.0f, whiteF, false,
  155.           "%s", pRuntime->GetComponent()->GetName());
  156.  
  157.         pRenderAux->SetRenderFlags(prevFlags);
  158. }
  159.  
  160. void DebugDrawComponentCollisions(CParticleComponentRuntime* pRuntime)
  161. {
  162.         IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
  163.         SAuxGeomRenderFlags prevFlags = pRenderAux->GetRenderFlags();
  164.         SAuxGeomRenderFlags curFlags = prevFlags;
  165.         Vec2 screenSz = Vec2(float(gEnv->pRenderer->GetWidth()), float(gEnv->pRenderer->GetHeight()));
  166.         curFlags.SetMode2D3DFlag(e_Mode3D);
  167.         curFlags.SetDepthTestFlag(e_DepthTestOn);
  168.         curFlags.SetDepthWriteFlag(e_DepthWriteOn);
  169.         pRenderAux->SetRenderFlags(curFlags);
  170.  
  171.         const auto context = SUpdateContext(pRuntime);
  172.         const CParticleContainer& container = pRuntime->GetContainer();
  173.         if (!container.HasData(EPDT_ContactPoint))
  174.                 return;
  175.         const TIStream<SContactPoint> contactPoints = container.GetTIStream<SContactPoint>(EPDT_ContactPoint);
  176.  
  177.         CRY_PFX2_FOR_ACTIVE_PARTICLES(context)
  178.         {
  179.                 SContactPoint contact = contactPoints.Load(particleId);
  180.  
  181.                 ColorB color = ColorB(0, 0, 0);
  182.                 if (contact.m_flags & uint(EContactPointsFlags::Ignore))
  183.                         color = ColorB(128, 128, 128);
  184.                 else if (contact.m_flags & uint(EContactPointsFlags::Sliding))
  185.                         color = ColorB(255, 128, 64);
  186.                 else
  187.                         color = ColorB(64, 128, 255);
  188.  
  189.                 pRenderAux->DrawSphere(contact.m_point, 0.05f, color);
  190.                 pRenderAux->DrawLine(
  191.                         contact.m_point, color,
  192.                         contact.m_point + contact.m_normal*0.25f, color);
  193.         }
  194.         CRY_PFX2_FOR_END;
  195.  
  196.         pRenderAux->SetRenderFlags(prevFlags);
  197. }
  198.  
  199. #if CRY_PLATFORM_SSE2
  200.  
  201. void DrawLineSSE(IRenderAuxGeom* pRenderAux, __m128 x, __m128 y, ColorB color)
  202. {
  203.         #if 0
  204.         pRenderAux->DrawLine(
  205.           Vec2(x.m128_f32[3], (1.0f - y.m128_f32[3]) * 0.9f + 0.05f), color,
  206.           Vec2(x.m128_f32[2], (1.0f - y.m128_f32[2]) * 0.9f + 0.05f), color, 1.0f);
  207.         pRenderAux->DrawLine(
  208.           Vec2(x.m128_f32[2], (1.0f - y.m128_f32[2]) * 0.9f + 0.05f), color,
  209.           Vec2(x.m128_f32[1], (1.0f - y.m128_f32[1]) * 0.9f + 0.05f), color, 1.0f);
  210.         pRenderAux->DrawLine(
  211.           Vec2(x.m128_f32[1], (1.0f - y.m128_f32[1]) * 0.9f + 0.05f), color,
  212.           Vec2(x.m128_f32[0], (1.0f - y.m128_f32[0]) * 0.9f + 0.05f), color, 1.0f);
  213.         #endif
  214. }
  215.  
  216. #endif
  217.  
  218. void DebugOptSpline()
  219. {
  220. #if 0
  221.         typedef spline::OptSpline<float> TOptSplineF;
  222.  
  223.         static bool init = false;
  224.         static TOptSplineF optSpline;
  225.         static CParticleSpline particleSpline;
  226.         if (!init)
  227.         {
  228.                 init = true;
  229.  
  230.                 CParticleSpline::CSourceSpline source;
  231.                 CParticleSpline::CSourceSpline::key_type key;
  232.  
  233.                 key.flags =
  234.                   (SPLINE_KEY_TANGENT_LINEAR << SPLINE_KEY_TANGENT_IN_SHIFT) |
  235.                   (SPLINE_KEY_TANGENT_NONE << SPLINE_KEY_TANGENT_OUT_SHIFT);
  236.                 key.time = 0.1f;
  237.                 key.value = 0.2f;
  238.                 source.insert_key(key);
  239.                 key.time = 0.25f;
  240.                 key.value = 1.0f;
  241.                 source.insert_key(key);
  242.                 key.time = 0.7f;
  243.                 key.value = 0.5f;
  244.                 source.insert_key(key);
  245.                 key.time = 0.95f;
  246.                 key.value = 0.0f;
  247.                 source.insert_key(key);
  248.  
  249.                 source.update();
  250.                 optSpline.from_source(source);
  251.                 particleSpline.FromSpline(source);
  252.         }
  253.  
  254.         IRenderer* pRender = gEnv->pRenderer;
  255.         IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
  256.         SAuxGeomRenderFlags prevFlags = pRenderAux->GetRenderFlags();
  257.         SAuxGeomRenderFlags curFlags = prevFlags;
  258.         Vec2 screenSz = Vec2(float(gEnv->pRenderer->GetWidth()), float(gEnv->pRenderer->GetHeight()));
  259.         curFlags.SetMode2D3DFlag(e_Mode2D);
  260.         pRenderAux->SetRenderFlags(curFlags);
  261.  
  262.         const int numSamples = 100;
  263.         const float sampleSz = 1.0f / numSamples;
  264.         float prevValue;
  265.  
  266.         optSpline.interpolate(0.0f, prevValue);
  267.         for (float t = sampleSz; t <= 1.0f; t += sampleSz)
  268.         {
  269.                 float curValue;
  270.                 optSpline.interpolate(t, curValue);
  271.                 pRenderAux->DrawLine(
  272.                   Vec2(t - sampleSz, (1.0f - prevValue) * 0.9f + 0.05f), red,
  273.                   Vec2(t, (1.0f - curValue) * 0.9f + 0.05f), red, 1.0f);
  274.                 prevValue = curValue;
  275.         }
  276.  
  277.         prevValue = particleSpline.Interpolate(0.0f);
  278.         for (float t = sampleSz; t <= 1.0f; t += sampleSz)
  279.         {
  280.                 float curValue;
  281.                 curValue = particleSpline.Interpolate(t);
  282.                 pRenderAux->DrawLine(
  283.                   Vec2(t - sampleSz, (1.0f - prevValue) * 0.9f + 0.05f), lightOrange,
  284.                   Vec2(t, (1.0f - curValue) * 0.9f + 0.05f), lightOrange, 1.0f);
  285.                 prevValue = curValue;
  286.         }
  287.  
  288.         const ColorB blue(128, 198, 255);
  289.         for (float t = 0.0f; t < 1.0f; t += sampleSz * 4.0f)
  290.         {
  291.                 __m128 timeSSE = _mm_set_ps(t, t + sampleSz, t + sampleSz * 2.0f, t + sampleSz * 3.0f);
  292.                 __m128 curValueSSE = particleSpline.Interpolate(timeSSE);
  293.                 DrawLineSSE(pRenderAux, timeSSE, curValueSSE, blue);
  294.         }
  295.  
  296.         pRenderAux->SetRenderFlags(prevFlags);
  297. #endif
  298. }
  299.  
  300. }
  301.  
  302. void DebugParticleSystem(const std::vector<_smart_ptr<CParticleEmitter>>& activeEmitters)
  303. {
  304.         DebugOptSpline();
  305.  
  306.         CVars* pCVars = static_cast<C3DEngine*>(gEnv->p3DEngine)->GetCVars();
  307.         const bool debugContainers = (pCVars->e_ParticlesDebug & AlphaBit('b')) != 0;
  308.         const bool debugCollisions = (pCVars->e_ParticlesDebug & AlphaBit('c')) != 0;
  309.  
  310.         if (debugContainers || debugCollisions)
  311.         {
  312.                 IRenderer* pRender = gEnv->pRenderer;
  313.                 IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();
  314.  
  315.                 size_t emitterBarIdx = 0;
  316.                 size_t barIdx = 0;
  317.                 for (CParticleEmitter* pEmitter : activeEmitters)
  318.                 {
  319.                         CParticleEffect* pEffect = pEmitter->GetCEffect();
  320.                         TComponentId lastComponentIt = pEffect->GetNumComponents();
  321.                         for (TComponentId componentId = 0; componentId < lastComponentIt; ++componentId)
  322.                         {
  323.                                 auto pComponentRuntime = pEmitter->GetRuntimes()[componentId].pRuntime->GetCpuRuntime();
  324.                                 if (!pComponentRuntime)
  325.                                         continue;
  326.                                 if (!pComponentRuntime->GetComponent()->IsEnabled())
  327.                                         continue;
  328.                                 if (debugContainers)
  329.                                         DebugDrawComponentRuntime(pComponentRuntime, emitterBarIdx, barIdx++);
  330.                                 if (debugCollisions)
  331.                                         DebugDrawComponentCollisions(pComponentRuntime);
  332.                         }
  333.                         emitterBarIdx = barIdx;
  334.                 }
  335.         }
  336. }
  337.  
  338. }
  339.  
downloadParticleDebug.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