BVB Source Codes

CRYENGINE Show FeatureRenderMeshes.cpp Source code

Return Download CRYENGINE: download FeatureRenderMeshes.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 <CrySerialization/Decorators/Resources.h>
  5. #include <CrySerialization/Math.h>
  6. #include "ParticleSystem/ParticleFeature.h"
  7.  
  8. CRY_PFX2_DBG
  9.  
  10. namespace pfx2
  11. {
  12.  
  13. EParticleDataType PDT(EPDT_MeshGeometry, IMeshObj*);
  14.  
  15. extern EParticleDataType EPDT_Alpha, EPDT_Color;
  16.  
  17.  
  18. SERIALIZATION_ENUM_DEFINE(ESizeMode, : uint8,
  19.                           Size,
  20.                           Scale
  21.                           )
  22.  
  23. SERIALIZATION_ENUM_DEFINE(EOriginMode, : uint8,
  24.                           Origin,
  25.                           Center
  26.                           )
  27.  
  28. SERIALIZATION_ENUM_DEFINE(EPiecesMode, : uint8,
  29.                           Whole,
  30.                           RandomPiece,
  31.                           AllPieces
  32.                           )
  33.  
  34. SERIALIZATION_ENUM_DEFINE(EPiecePlacement, : uint8,
  35.                           Standard,
  36.                           SubPlacement,
  37.                           CenteredSubPlacement
  38.                           )
  39.  
  40. class CFeatureRenderMeshes : public CParticleFeature, public Cry3DEngineBase
  41. {
  42. public:
  43.         CRY_PFX2_DECLARE_FEATURE
  44.  
  45.         CFeatureRenderMeshes()
  46.                 : m_scale(1.0f, 1.0f, 1.0f)
  47.                 , m_sizeMode(ESizeMode::Scale)
  48.                 , m_originMode(EOriginMode::Origin)
  49.                 , m_piecesMode(EPiecesMode::RandomPiece)
  50.                 , m_piecePlacement(EPiecePlacement::Standard)
  51.         {}
  52.  
  53.         virtual void Serialize(Serialization::IArchive& ar) override
  54.         {
  55.                 CParticleFeature::Serialize(ar);
  56.                 ar(Serialization::ModelFilename(m_meshName), "Mesh", "Mesh");
  57.                 ar(m_scale, "Scale", "Scale");
  58.                 ar(m_sizeMode, "SizeMode", "Size Mode");
  59.                 ar(m_originMode, "OriginMode", "Origin Mode");
  60.                 ar(m_piecesMode, "PiecesMode", "Pieces Mode");
  61.                 ar(m_piecePlacement, "PiecePlacement", "Piece Placement");
  62.         }
  63.  
  64.         virtual EFeatureType GetFeatureType() override { return EFT_Render; }
  65.  
  66.         virtual void         AddToComponent(CParticleComponent* pComponent, SComponentParams* pParams) override
  67.         {
  68.                 pParams->m_pMesh = m_pStaticObject = Get3DEngine()->LoadStatObj(m_meshName.c_str(), NULL, NULL, true);
  69.                 pParams->m_meshCentered = m_originMode == EOriginMode::Center;
  70.                 if (m_pStaticObject)
  71.                 {
  72.                         pComponent->AddToUpdateList(EUL_RenderDeferred, this);
  73.                         pComponent->AddParticleData(EPVF_Position);
  74.                         pComponent->AddParticleData(EPQF_Orientation);
  75.  
  76.                         m_aSubObjects.clear();
  77.                         if (m_piecesMode != EPiecesMode::Whole)
  78.                         {
  79.                                 int subObjectCount = m_pStaticObject->GetSubObjectCount();
  80.                                 for (int i = 0; i < subObjectCount; ++i)
  81.                                 {
  82.                                         if (IStatObj::SSubObject* pSub = m_pStaticObject->GetSubObject(i))
  83.                                                 if (pSub->nType == STATIC_SUB_OBJECT_MESH && pSub->pStatObj && pSub->pStatObj->GetRenderMesh())
  84.                                                         m_aSubObjects.push_back(pSub);
  85.                                 }
  86.  
  87.                                 if (m_aSubObjects.size() > 0)
  88.                                 {
  89.                                         // Require per-particle sub-objects
  90.                                         assert(m_aSubObjects.size() < 256);
  91.                                         pComponent->AddToUpdateList(EUL_InitUpdate, this);
  92.                                         pComponent->AddParticleData(EPDT_MeshGeometry);
  93.                                         if (m_piecesMode == EPiecesMode::AllPieces)
  94.                                         {
  95.                                                 pComponent->AddParticleData(EPDT_SpawnId);
  96.                                                 pParams->m_scaleParticleCount *= m_aSubObjects.size();
  97.                                         }
  98.                                 }
  99.                         }
  100.                 }
  101.         }
  102.  
  103.         virtual void InitParticles(const SUpdateContext& context) override
  104.         {
  105.                 CRY_PROFILE_FUNCTION(PROFILE_PARTICLE);
  106.  
  107.                 CParticleContainer& container = context.m_container;
  108.                 TIOStream<IMeshObj*> meshes = container.GetTIOStream<IMeshObj*>(EPDT_MeshGeometry);
  109.                 TIStream<uint> spawnIds = container.GetTIStream<uint>(EPDT_SpawnId);
  110.                 IOVec3Stream positions = container.GetIOVec3Stream(EPVF_Position);
  111.                 IOQuatStream orientations = container.GetIOQuatStream(EPQF_Orientation);
  112.                 uint pieceCount = m_aSubObjects.size();
  113.                 Vec3 center = m_pStaticObject->GetAABB().GetCenter();
  114.  
  115.                 CRY_PFX2_FOR_SPAWNED_PARTICLES(context)
  116.                 {
  117.                         uint piece;
  118.                         if (m_piecesMode == EPiecesMode::RandomPiece)
  119.                         {
  120.                                 piece = context.m_spawnRng.Rand();
  121.                         }
  122.                         else if (m_piecesMode == EPiecesMode::AllPieces)
  123.                         {
  124.                                 piece = spawnIds.Load(particleId);
  125.                         }
  126.                         piece %= pieceCount;
  127.  
  128.                         IMeshObj* mesh = m_aSubObjects[piece]->pStatObj;
  129.                         meshes.Store(particleId, mesh);
  130.  
  131.                         if (m_piecePlacement != EPiecePlacement::Standard)
  132.                         {
  133.                                 Vec3 position = positions.Load(particleId);
  134.                                 Quat orientation = orientations.Load(particleId);
  135.  
  136.                                 if (m_piecePlacement == EPiecePlacement::CenteredSubPlacement)
  137.                                 {
  138.                                         // Offset by main object center
  139.                                         position -= orientation * center;
  140.                                 }
  141.  
  142.                                 // Place pieces according to sub-transforms; scale is ignored
  143.                                 Matrix34 const& localTM = m_aSubObjects[piece]->localTM;
  144.  
  145.                                 position += orientation * localTM.GetTranslation();
  146.                                 orientation = orientation * Quat(localTM);
  147.  
  148.                                 if (m_originMode == EOriginMode::Center)
  149.                                 {
  150.                                         Vec3 subCenter = m_aSubObjects[piece]->pStatObj->GetAABB().GetCenter();
  151.                                         position += orientation * subCenter;
  152.                                 }
  153.  
  154.                                 positions.Store(particleId, position);
  155.                                 orientations.Store(particleId, orientation);
  156.                         }
  157.                 }
  158.                 CRY_PFX2_FOR_END;
  159.         }
  160.  
  161.         virtual void Render(CParticleEmitter* pEmitter, ICommonParticleComponentRuntime* pCommonComponentRuntime, CParticleComponent* pComponent, const SRenderContext& renderContext) override
  162.         {
  163.                 CRY_PROFILE_FUNCTION(PROFILE_PARTICLE);
  164.  
  165.                 CParticleComponentRuntime* pComponentRuntime = pCommonComponentRuntime->GetCpuRuntime();
  166.                 if (!pComponentRuntime)
  167.                         return;
  168.                 auto context = SUpdateContext(pComponentRuntime);
  169.                 auto& passInfo = renderContext.m_passInfo;
  170.                 SRendParams renderParams = renderContext.m_renderParams;
  171.  
  172.                 const CParticleContainer& container = context.m_container;
  173.                 const IVec3Stream positions = container.GetIVec3Stream(EPVF_Position);
  174.                 const IQuatStream orientations = container.GetIQuatStream(EPQF_Orientation);
  175.                 const IFStream alphas = container.GetIFStream(EPDT_Alpha, 1.0f);
  176.                 const IFStream sizes = container.GetIFStream(EPDT_Size, 1.0f);
  177.                 const TIStream<IMeshObj*> meshes = container.GetTIStream<IMeshObj*>(EPDT_MeshGeometry);
  178.                 const Vec3 camPosition = passInfo.GetCamera().GetPosition();
  179.                 const bool hasAlphas = container.HasData(EPDT_Alpha);
  180.                 const bool hasPieces = container.HasData(EPDT_MeshGeometry);
  181.  
  182.                 IMeshObj* pMeshObj = m_pStaticObject;
  183.  
  184.                 const AABB bBox = m_pStaticObject->GetAABB();
  185.                 const float invObjectSize = (m_sizeMode == ESizeMode::Size) ? rsqrt_fast(bBox.GetRadiusSqr()) : 1.0f;
  186.                 Vec3 offset = (m_originMode == EOriginMode::Center) ? -bBox.GetCenter() : Vec3(ZERO);
  187.  
  188.                 renderParams.dwFObjFlags |= FOB_TRANS_MASK;
  189.  
  190.                 CRY_PFX2_FOR_ACTIVE_PARTICLES(context)
  191.                 {
  192.                         const Vec3 position = positions.Load(particleId);
  193.                         const Quat orientation = orientations.Load(particleId);
  194.                         const float size = sizes.Load(particleId);
  195.                         const Vec3 scale = m_scale * size * invObjectSize;
  196.  
  197.                         Matrix34 wsMatrix(scale, orientation, position);
  198.  
  199.                         if (hasPieces)
  200.                         {
  201.                                 pMeshObj = meshes.Load(particleId);
  202.                                 if (!pMeshObj)
  203.                                         continue;
  204.                                 offset = -pMeshObj->GetAABB().GetCenter();
  205.                         }
  206.  
  207.                         if (m_originMode == EOriginMode::Center)
  208.                                 wsMatrix.SetTranslation(wsMatrix * offset);
  209.  
  210.                         renderParams.fAlpha = alphas.SafeLoad(particleId);
  211.  
  212.                         // Trigger transparency rendering if any particles can be transparent.
  213.                         if (!passInfo.IsShadowPass() && hasAlphas)
  214.                                 renderParams.fAlpha *= 0.999f;
  215.  
  216.                         renderParams.fDistance = camPosition.GetDistance(position);
  217.                         renderParams.pMatrix = &wsMatrix;
  218.                         renderParams.pInstance = &non_const(*this);
  219.                         pMeshObj->Render(renderParams, passInfo);
  220.                 }
  221.                 CRY_PFX2_FOR_END;
  222.         }
  223.  
  224. private:
  225.         string                             m_meshName;
  226.         Vec3                               m_scale;
  227.         ESizeMode                          m_sizeMode;
  228.         EOriginMode                        m_originMode;
  229.         EPiecesMode                        m_piecesMode;
  230.         EPiecePlacement                    m_piecePlacement;
  231.  
  232.         _smart_ptr<IStatObj>               m_pStaticObject;
  233.         std::vector<IStatObj::SSubObject*> m_aSubObjects;
  234. };
  235.  
  236. CRY_PFX2_IMPLEMENT_FEATURE(CParticleFeature, CFeatureRenderMeshes, "Render", "Meshes", colorRender);
  237.  
  238. }
  239.  
downloadFeatureRenderMeshes.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