BVB Source Codes

CRYENGINE Show FeatureProject.cpp Source code

Return Download CRYENGINE: download FeatureProject.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 "ParticleSystem/ParticleFeature.h"
  5. #include "ParticleSystem/ParticleEmitter.h"
  6. #include "ParamTraits.h"
  7. #include "FeatureAngles.h"
  8.  
  9. CRY_PFX2_DBG
  10.  
  11. namespace pfx2
  12. {
  13.  
  14. //////////////////////////////////////////////////////////////////////////
  15. // CFeatureProjectBase
  16.  
  17. class CFeatureProjectBase : public CParticleFeature
  18. {
  19. public:
  20.         typedef TParticleHeap::Array<PosNorm> TPosNormArray;
  21.  
  22. public:
  23.         CFeatureProjectBase()
  24.                 : m_alignAxis(EAlignParticleAxis::Normal)
  25.                 , m_alignView(EAlignView::None)
  26.                 , m_offset(0.0f)
  27.                 , m_projectPosition(true)
  28.                 , m_projectVelocity(true)
  29.                 , m_projectAngles(false)
  30.                 , m_spawnOnly(false) {}
  31.  
  32.         virtual void AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  33.         {
  34.                 if (m_spawnOnly)
  35.                         pComponent->AddToUpdateList(EUL_InitUpdate, this);
  36.                 else
  37.                         pComponent->AddToUpdateList(EUL_Update, this);
  38.                 if (m_projectPosition)
  39.                         pComponent->AddParticleData(EPVF_Position);
  40.                 if (m_projectVelocity)
  41.                         pComponent->AddParticleData(EPVF_Velocity);
  42.                 if (m_projectAngles)
  43.                         pComponent->AddParticleData(EPQF_Orientation);
  44.         }
  45.  
  46.         virtual void Serialize(Serialization::IArchive& ar) override
  47.         {
  48.                 CParticleFeature::Serialize(ar);
  49.                 ar(m_spawnOnly, "SpawnOnly", "Spawn Only");
  50.                 ar(m_projectPosition, "ProjectPosition", "Project Positions");
  51.                 if (m_spawnOnly && m_projectPosition)
  52.                         ar(m_offset, "Offset", "Offset");
  53.                 else
  54.                         m_offset = 0.0f;
  55.                 ar(m_projectVelocity, "ProjectVelocity", "Project Velocities");
  56.                 ar(m_projectAngles, "ProjectAngles", "Project Angles");
  57.                 if (m_projectAngles)
  58.                 {
  59.                         ar(m_alignAxis, "AlignAxis", "Align Axis");
  60.                         ar(m_alignView, "AlignView", "Align View");
  61.                 }
  62.         }
  63.  
  64.         virtual void InitParticles(const SUpdateContext& context) override
  65.         {
  66.                 CRY_PFX2_PROFILE_DETAIL;
  67.                 Project(context, context.m_container.GetSpawnedRange());
  68.         }
  69.  
  70.         virtual void Update(const SUpdateContext& context) override
  71.         {
  72.                 CRY_PFX2_PROFILE_DETAIL;
  73.                 Project(context, context.m_updateRange);
  74.         }
  75.  
  76. private:
  77.         virtual void FillSamples(const SUpdateContext& context, const SUpdateRange& range, TPosNormArray& samples) = 0;
  78.  
  79.         ILINE void Project(const SUpdateContext& context, const SUpdateRange& range)
  80.         {
  81.                 const Matrix34 viewTM = gEnv->p3DEngine->GetRenderingCamera().GetMatrix();
  82.                 const Vec3 cameraPos = gEnv->p3DEngine->GetRenderingCamera().GetPosition();
  83.                 const Vec3 forward = -viewTM.GetColumn1();
  84.  
  85.                 CParticleContainer& container = context.m_container;
  86.  
  87.                 TPosNormArray posNormArray(*context.m_pMemHeap, container.GetMaxParticles());
  88.                 FillSamples(context, range, posNormArray);
  89.  
  90.                 IOVec3Stream positions = container.GetIOVec3Stream(EPVF_Position);
  91.                 IOVec3Stream velocities = container.GetIOVec3Stream(EPVF_Velocity);
  92.                 IOQuatStream orientations = container.GetIOQuatStream(EPQF_Orientation);
  93.  
  94.                 CRY_PFX2_FOR_RANGE_PARTICLES(range)
  95.                 {
  96.                         const PosNorm posNormSample = posNormArray[particleId];
  97.  
  98.                         if (m_projectPosition)
  99.                         {
  100.                                 const Vec3 position1 = posNormSample.vPos + posNormSample.vNorm * m_offset;
  101.                                 positions.Store(particleId, position1);
  102.                         }
  103.  
  104.                         if (m_projectVelocity)
  105.                         {
  106.                                 const Vec3 velocity0 = velocities.Load(particleId);
  107.                                 const Vec3 normalVelocity = posNormSample.vNorm * posNormSample.vNorm.Dot(velocity0);
  108.                                 const Vec3 tangentVelocity = velocity0 - normalVelocity;
  109.                                 velocities.Store(particleId, tangentVelocity);
  110.                         }
  111.  
  112.                         if (m_projectAngles)
  113.                         {
  114.                                 const Quat orientation0 = orientations.Load(particleId);
  115.                                 const Vec3 particleAxis = GetParticleAxis(m_alignAxis, orientation0);
  116.                                 const Quat fieldAlign = Quat::CreateRotationV0V1(particleAxis, posNormSample.vNorm);
  117.                                 const Quat orientation1 = fieldAlign * orientation0;
  118.  
  119.                                 if (m_alignView != EAlignView::None)
  120.                                 {
  121.                                         const Vec3 position = positions.Load(particleId);
  122.                                         const Vec3 toCamera = m_alignView == EAlignView::Camera ? (cameraPos - position).GetNormalized() : forward;
  123.                                         const Vec3 particleOtherAxis = GetParticleOtherAxis(m_alignAxis, orientation1);
  124.                                         const Vec3 cameraAlignAxis = posNormSample.vNorm.Cross(toCamera).GetNormalizedSafe();
  125.                                         const Quat cameraAlign = Quat::CreateRotationV0V1(particleOtherAxis, cameraAlignAxis);
  126.                                         const Quat orientation2 = cameraAlign * orientation1;
  127.                                         orientations.Store(particleId, orientation2);
  128.                                 }
  129.                                 else
  130.                                 {
  131.                                         orientations.Store(particleId, orientation1);
  132.                                 }
  133.                         }
  134.                 }
  135.                 CRY_PFX2_FOR_END;
  136.         }
  137.  
  138. private:
  139.         EAlignParticleAxis m_alignAxis;
  140.         EAlignView         m_alignView;
  141.         UFloat             m_offset;
  142.         bool               m_projectPosition;
  143.         bool               m_projectVelocity;
  144.         bool               m_projectAngles;
  145.         bool               m_spawnOnly;
  146. };
  147.  
  148. //////////////////////////////////////////////////////////////////////////
  149. // CFeatureProjectTerrain
  150.  
  151. class CFeatureProjectTerrain : public CFeatureProjectBase
  152. {
  153. public:
  154.         CRY_PFX2_DECLARE_FEATURE
  155.  
  156. private:
  157.         virtual void FillSamples(const SUpdateContext& context, const SUpdateRange& range, TPosNormArray& samples) override
  158.         {
  159.                 CTerrain* pTerrain = context.m_runtime.GetEmitter()->GetTerrain();
  160.  
  161.                 const CParticleContainer& container = context.m_container;
  162.                 const IVec3Stream positions = container.GetIVec3Stream(EPVF_Position);
  163.                 const IFStream sizes = container.GetIFStream(EPDT_Size);
  164.  
  165.                 CRY_PFX2_FOR_RANGE_PARTICLES(range)
  166.                 {
  167.                         const Vec3 position = positions.Load(particleId);
  168.                         const float size = sizes.Load(particleId);
  169.                         samples[particleId] = SampleTerrain(*pTerrain, position, size);
  170.                 }
  171.                 CRY_PFX2_FOR_END;
  172.         }
  173.  
  174.         ILINE PosNorm SampleTerrain(const CTerrain& terrain, const Vec3 position, const float size) const
  175.         {
  176.                 PosNorm out;
  177.                 out.vPos.x = position.x;
  178.                 out.vPos.y = position.y;
  179.  
  180.                 Vec3 samplers[4] =
  181.                 {
  182.                         Vec3(position.x + size, position.y       , 0.0f),
  183.                         Vec3(position.x - size, position.y       , 0.0f),
  184.                         Vec3(position.x       , position.y + size, 0.0f),
  185.                         Vec3(position.x       , position.y - size, 0.0f),
  186.                 };
  187.                 for (uint i = 0; i < 4; ++i)
  188.                         samplers[i].z = terrain.GetZApr(samplers[i].x, samplers[i].y, DEFAULT_SID);
  189.  
  190.                 out.vPos.z = (samplers[0].z + samplers[1].z + samplers[2].z + samplers[3].z) * 0.25f;
  191.                 out.vNorm = (samplers[1] - samplers[0]).Cross(samplers[3] - samplers[2]).GetNormalizedSafe();
  192.  
  193.                 return out;
  194.         }
  195. };
  196.  
  197. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureProjectTerrain, "Project", "Terrain", colorProject);
  198.  
  199. //////////////////////////////////////////////////////////////////////////
  200. // CFeatureProjectWater
  201.  
  202. class CFeatureProjectWater : public CFeatureProjectBase
  203. {
  204. public:
  205.         CRY_PFX2_DECLARE_FEATURE
  206.  
  207. private:
  208.         virtual void FillSamples(const SUpdateContext& context, const SUpdateRange& range, TPosNormArray& samples) override
  209.         {
  210.                 const SPhysEnviron& physicsEnvironment = context.m_runtime.GetEmitter()->GetPhysicsEnv();
  211.                 CParticleContainer& container = context.m_container;
  212.                 const IVec3Stream positions = container.GetIVec3Stream(EPVF_Position);
  213.                 auto states = container.GetTIOStream<uint8>(EPDT_State);
  214.                 IOFStream ages = container.GetIOFStream(EPDT_NormalAge);
  215.  
  216.                 CRY_PFX2_FOR_RANGE_PARTICLES(range)
  217.                 {
  218.                         Plane waterPlane;
  219.                         const Vec3 position = positions.Load(particleId);
  220.                         physicsEnvironment.GetWaterPlane(waterPlane, position);
  221.                         if (waterPlane.d < -WATER_LEVEL_UNKNOWN)
  222.                         {
  223.                                 const float distToWater = waterPlane.DistFromPlane(position);
  224.                                 samples[particleId].vPos = position - waterPlane.n * distToWater;
  225.                                 samples[particleId].vNorm = waterPlane.n;
  226.                         }
  227.                         else
  228.                         {
  229.                                 samples[particleId].vPos = Vec3(ZERO);
  230.                                 samples[particleId].vNorm = Vec3(ZERO);
  231.                                 states.Store(particleId, ES_Expired);
  232.                                 ages.Store(particleId, 1.0f);
  233.                         }
  234.                 }
  235.                 CRY_PFX2_FOR_END;
  236.         }
  237. };
  238.  
  239. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureProjectWater, "Project", "Water", colorProject);
  240.  
  241. }
  242.  
downloadFeatureProject.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