BVB Source Codes

CRYENGINE Show ProceduralClipProps.cpp Source code

Return Download CRYENGINE: download ProceduralClipProps.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. //
  4. ////////////////////////////////////////////////////////////////////////////
  5.  
  6. #include "StdAfx.h"
  7.  
  8. #include "ICryMannequin.h"
  9.  
  10. #include <Mannequin/Serialization.h>
  11.  
  12. struct SProceduralClipAttachPropParams : public IProceduralParams
  13. {
  14.         virtual void Serialize(Serialization::IArchive& ar)
  15.         {
  16.                 ar(Serialization::Decorators::ObjectFilename<TProcClipString>(objectFilename), "ObjectFilename", "Object Filename");
  17.                 ar(Serialization::Decorators::AttachmentName<SProcDataCRC>(attachmentName), "AttachmentName", "Attachment Name");
  18.         }
  19.  
  20.         TProcClipString objectFilename;
  21.         SProcDataCRC    attachmentName;
  22. };
  23.  
  24. class CProceduralClipAttachProp : public TProceduralClip<SProceduralClipAttachPropParams>
  25. {
  26. public:
  27.         CProceduralClipAttachProp()
  28.                 : m_attachmentCRC(0)
  29.         {
  30.         }
  31.  
  32.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipAttachPropParams& params)
  33.         {
  34.                 if (m_charInstance)
  35.                 {
  36.                         IAttachmentManager* pAttachmentManager = m_charInstance->GetIAttachmentManager();
  37.  
  38.                         if (IAttachment* pAttachment = pAttachmentManager->GetInterfaceByNameCRC(params.attachmentName.crc))
  39.                         {
  40.                                 m_attachmentCRC = params.attachmentName.crc;
  41.  
  42.                                 const char* fileExt = PathUtil::GetExt(params.objectFilename.c_str());
  43.  
  44.                                 if (0 == stricmp(fileExt, "cgf"))
  45.                                 {
  46.                                         if (m_pAttachedStatObj = gEnv->p3DEngine->LoadStatObj(params.objectFilename.c_str(), NULL, NULL, false))
  47.                                         {
  48.                                                 CCGFAttachment* pCGFAttachment = new CCGFAttachment();
  49.                                                 pCGFAttachment->pObj = m_pAttachedStatObj;
  50.                                                 pAttachment->AddBinding(pCGFAttachment);
  51.                                         }
  52.                                 }
  53.                                 else if (0 == stricmp(fileExt, "skin"))
  54.                                 {
  55.                                         if (IAttachment* pAttach = pAttachmentManager->GetInterfaceByNameCRC(params.attachmentName.crc))
  56.                                         {
  57.                                                 if (IAttachmentSkin* pSkinAttach = pAttach->GetIAttachmentSkin())
  58.                                                 {
  59.                                                         if (ISkin* pSkin = gEnv->pCharacterManager->LoadModelSKIN(params.objectFilename.c_str(), 0))
  60.                                                         {
  61.                                                                 CSKINAttachment* pSkinAttachment = new CSKINAttachment();
  62.                                                                 pSkinAttachment->m_pIAttachmentSkin = pSkinAttach;
  63.                                                                 pAttachment->AddBinding(pSkinAttachment, pSkin, 0);
  64.                                                         }
  65.                                                 }
  66.                                         }
  67.                                 }
  68.                                 else if (m_pAttachedCharInst = gEnv->pCharacterManager->CreateInstance(params.objectFilename.c_str()))
  69.                                 {
  70.                                         CSKELAttachment* pChrAttachment = new CSKELAttachment();
  71.                                         pChrAttachment->m_pCharInstance = m_pAttachedCharInst;
  72.                                         pAttachment->AddBinding(pChrAttachment);
  73.                                 }
  74.                         }
  75.                 }
  76.         }
  77.  
  78.         virtual void OnExit(float blendTime)
  79.         {
  80.                 if (m_pAttachedCharInst || m_pAttachedStatObj)
  81.                 {
  82.                         if (IAttachment* pAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(m_attachmentCRC))
  83.                         {
  84.                                 if (IAttachmentObject* pAttachmentObject = pAttachment->GetIAttachmentObject())
  85.                                 {
  86.                                         //ensure the correct model is still bound to the attachment before clearing
  87.                                         if ((m_pAttachedCharInst && pAttachmentObject->GetICharacterInstance() == m_pAttachedCharInst)
  88.                                             || (m_pAttachedStatObj && pAttachmentObject->GetIStatObj() == m_pAttachedStatObj))
  89.                                         {
  90.                                                 pAttachment->ClearBinding();
  91.                                         }
  92.                                 }
  93.                         }
  94.                 }
  95.  
  96.                 m_pAttachedStatObj = NULL;
  97.                 m_pAttachedCharInst = NULL;
  98.         }
  99.  
  100.         virtual void Update(float timePassed) {}
  101.  
  102. private:
  103.         uint32                         m_attachmentCRC; //TODO: This should be available via m_pParams pointer but currently is cleared by the time OnExit is called. Remove once fixed by Tom
  104.         _smart_ptr<IStatObj>           m_pAttachedStatObj;
  105.         _smart_ptr<ICharacterInstance> m_pAttachedCharInst;
  106. };
  107.  
  108. REGISTER_PROCEDURAL_CLIP(CProceduralClipAttachProp, "AttachProp");
  109.  
  110. struct SProceduralClipAttachEntityParams : public IProceduralParams
  111. {
  112.         virtual void Serialize(Serialization::IArchive& ar)
  113.         {
  114.                 ar(Serialization::Decorators::AttachmentName<SProcDataCRC>(attachmentName), "AttachmentName", "Attachment Name");
  115.                 ar(entityIdParamName, "EntityIdParamName", "Param Name With EntityId");
  116.         }
  117.  
  118.         SProcDataCRC    attachmentName;
  119.         TProcClipString entityIdParamName;
  120. };
  121.  
  122. class CProceduralClipAttachEntity : public TProceduralClip<SProceduralClipAttachEntityParams>
  123. {
  124. public:
  125.         CProceduralClipAttachEntity();
  126.  
  127.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipAttachEntityParams& params)
  128.         {
  129.                 if (m_charInstance)
  130.                 {
  131.                         if (IAttachment* pAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(params.attachmentName.crc))
  132.                         {
  133.                                 m_attachedEntityId = 0;
  134.                                 m_attachmentCRC = params.attachmentName.crc;
  135.                                 IAttachmentObject* pNewAttachment = NULL;
  136.  
  137.                                 EntityId attachEntityId = 0;
  138.  
  139.                                 GetParam(params.entityIdParamName.c_str(), attachEntityId);
  140.  
  141.                                 if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(attachEntityId))
  142.                                 {
  143.                                         CEntityAttachment* pEntityAttachment = new CEntityAttachment();
  144.                                         pEntityAttachment->SetEntityId(attachEntityId);
  145.  
  146.                                         pAttachment->AddBinding(pEntityAttachment);
  147.                                         m_attachedEntityId = attachEntityId;
  148.  
  149.                                         if (IPhysicalEntity* pPhysics = pEntity->GetPhysics())
  150.                                         {
  151.                                                 pe_action_add_constraint constraint;
  152.                                                 constraint.flags = constraint_inactive | constraint_ignore_buddy;
  153.                                                 constraint.pBuddy = m_scope->GetEntity().GetPhysics();
  154.                                                 constraint.pt[0].Set(0, 0, 0);
  155.                                                 m_attachedConstraintId = pPhysics->Action(&constraint);
  156.  
  157.                                                 pe_params_part colltype;
  158.                                                 colltype.flagsOR = geom_no_coll_response;
  159.                                                 pPhysics->SetParams(&colltype);
  160.                                         }
  161.                                 }
  162.                         }
  163.                 }
  164.         }
  165.  
  166.         virtual void OnExit(float blendTime)
  167.         {
  168.                 if (m_attachedEntityId)
  169.                 {
  170.                         if (IAttachment* pAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(m_attachmentCRC))
  171.                         {
  172.                                 if (IAttachmentObject* pAttachmentObject = pAttachment->GetIAttachmentObject())
  173.                                 {
  174.                                         //ensure the correct entity is still bound to the attachment before clearing
  175.                                         if (pAttachmentObject->GetAttachmentType() == IAttachmentObject::eAttachment_Entity)
  176.                                         {
  177.                                                 if (static_cast<CEntityAttachment*>(pAttachmentObject)->GetEntityId() == m_attachedEntityId)
  178.                                                 {
  179.                                                         pAttachment->ClearBinding();
  180.  
  181.                                                         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_attachedEntityId))
  182.                                                         {
  183.                                                                 if (IPhysicalEntity* pPhysics = pEntity->GetPhysics())
  184.                                                                 {
  185.                                                                         pe_action_update_constraint constraint;
  186.                                                                         constraint.bRemove = true;
  187.                                                                         constraint.idConstraint = m_attachedConstraintId;
  188.                                                                         pPhysics->Action(&constraint);
  189.  
  190.                                                                         pe_params_part colltype;
  191.                                                                         colltype.flagsAND = ~geom_no_coll_response;
  192.                                                                         pPhysics->SetParams(&colltype);
  193.  
  194.                                                                         pe_action_awake action;
  195.                                                                         action.bAwake = true;
  196.                                                                         action.minAwakeTime = 0.5f;
  197.                                                                         pPhysics->Action(&action);
  198.                                                                 }
  199.                                                         }
  200.                                                 }
  201.                                         }
  202.                                 }
  203.                         }
  204.                 }
  205.  
  206.                 m_attachedEntityId = 0;
  207.                 m_attachedConstraintId = 0;
  208.         }
  209.  
  210.         virtual void Update(float timePassed) {}
  211.  
  212. private:
  213.         uint32   m_attachmentCRC;
  214.         EntityId m_attachedEntityId;
  215.         uint     m_attachedConstraintId;
  216. };
  217.  
  218. REGISTER_PROCEDURAL_CLIP(CProceduralClipAttachEntity, "AttachEntity")
  219.  
  220. CProceduralClipAttachEntity::CProceduralClipAttachEntity() : m_attachmentCRC(0), m_attachedEntityId(0), m_attachedConstraintId(0)
  221. {
  222. }
  223.  
  224. struct SSwapAttachmentParams : public IProceduralParams
  225. {
  226.         SProcDataCRC attachmentNameOld;
  227.         SProcDataCRC attachmentNameNew;
  228.         bool         resetOnExit;
  229.         bool         clearOnExit;
  230.  
  231.         SSwapAttachmentParams()
  232.                 : resetOnExit(false)
  233.                 , clearOnExit(false)
  234.         {
  235.         }
  236.  
  237.         virtual void Serialize(Serialization::IArchive& ar)
  238.         {
  239.                 ar(Serialization::Decorators::AttachmentName<SProcDataCRC>(attachmentNameOld), "AttachmentNameOld", "Attachment Name Old");
  240.                 ar(Serialization::Decorators::AttachmentName<SProcDataCRC>(attachmentNameNew), "AttachmentNameNew", "Attachment Name New");
  241.                 ar(resetOnExit, "ResetOnExit", "Reset on Exit");
  242.                 ar(clearOnExit, "ClearOnExit", "Clear on Exit");
  243.         }
  244. };
  245.  
  246. class CProceduralClipSwapAttachment : public TProceduralClip<SSwapAttachmentParams>
  247. {
  248. public:
  249.         CProceduralClipSwapAttachment()
  250.                 : m_newAttachmentCRC(0)
  251.                 , m_oldAttachmentCRC(0)
  252.         {
  253.         }
  254.  
  255.         virtual void OnEnter(float blendTime, float duration, const SSwapAttachmentParams& params)
  256.         {
  257.                 m_newAttachmentCRC = 0;
  258.                 m_oldAttachmentCRC = 0;
  259.  
  260.                 if (m_charInstance)
  261.                 {
  262.                         if (IAttachment* pNewAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(params.attachmentNameNew.crc))
  263.                         {
  264.                                 if (IAttachment* pOldAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(params.attachmentNameOld.crc))
  265.                                 {
  266.                                         if (pNewAttachment->GetIAttachmentObject() == NULL && pOldAttachment->GetIAttachmentObject() != NULL)
  267.                                         {
  268.                                                 if (params.resetOnExit)
  269.                                                 {
  270.                                                         m_oldAttachmentCRC = params.attachmentNameOld.crc;
  271.                                                         m_newAttachmentCRC = params.attachmentNameNew.crc;
  272.                                                 }
  273.                                                 else if (params.clearOnExit)
  274.                                                 {
  275.                                                         m_newAttachmentCRC = params.attachmentNameNew.crc;
  276.                                                 }
  277.  
  278.                                                 pOldAttachment->SwapBinding(pNewAttachment);
  279.                                         }
  280.                                 }
  281.                         }
  282.                 }
  283.         }
  284.  
  285.         virtual void OnExit(float blendTime)
  286.         {
  287.                 if (m_newAttachmentCRC != 0)
  288.                 {
  289.                         if (IAttachment* pNewAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(m_newAttachmentCRC))
  290.                         {
  291.                                 if (m_oldAttachmentCRC != 0)
  292.                                 {
  293.                                         if (IAttachment* pOldAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(m_oldAttachmentCRC))
  294.                                         {
  295.                                                 if (pOldAttachment->GetIAttachmentObject() == NULL && pNewAttachment->GetIAttachmentObject() != NULL)
  296.                                                 {
  297.                                                         pNewAttachment->SwapBinding(pOldAttachment);
  298.                                                 }
  299.                                         }
  300.                                 }
  301.                                 else
  302.                                 {
  303.                                         pNewAttachment->ClearBinding();
  304.                                 }
  305.                         }
  306.                 }
  307.         }
  308.  
  309.         virtual void Update(float timePassed) {}
  310.  
  311. private:
  312.         uint32 m_newAttachmentCRC;
  313.         uint32 m_oldAttachmentCRC;
  314. };
  315.  
  316. REGISTER_PROCEDURAL_CLIP(CProceduralClipSwapAttachment, "SwapAttachment");
  317.  
  318. struct SProceduralClipHideAttachmentParams : public IProceduralParams
  319. {
  320.         SProcDataCRC attachmentName;
  321.  
  322.         virtual void Serialize(Serialization::IArchive& ar)
  323.         {
  324.                 ar(Serialization::Decorators::AttachmentName<SProcDataCRC>(attachmentName), "AttachmentName", "Attachment Name");
  325.         }
  326. };
  327.  
  328. class CProceduralClipHideAttachment : public TProceduralClip<SProceduralClipHideAttachmentParams>
  329. {
  330. public:
  331.         enum EHideFlags
  332.         {
  333.                 eHideFlags_HiddenInMainPass  = BIT(0),
  334.                 eHideFlags_HiddenInShadow    = BIT(1),
  335.                 eHideFlags_HiddenInRecursion = BIT(2),
  336.         };
  337.  
  338.         CProceduralClipHideAttachment()
  339.                 : m_attachmentCRC(0)
  340.                 , m_hiddenFlags(0)
  341.         {
  342.         }
  343.  
  344.         virtual void OnEnter(float blendTime, float duration, const SProceduralClipHideAttachmentParams& params)
  345.         {
  346.                 m_attachmentCRC = 0;
  347.                 m_hiddenFlags = 0;
  348.  
  349.                 if (m_charInstance)
  350.                 {
  351.                         if (IAttachment* pAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(params.attachmentName.crc))
  352.                         {
  353.                                 m_attachmentCRC = params.attachmentName.crc;
  354.  
  355.                                 if (pAttachment->IsAttachmentHidden())
  356.                                 {
  357.                                         m_hiddenFlags |= eHideFlags_HiddenInMainPass;
  358.                                 }
  359.  
  360.                                 if (pAttachment->IsAttachmentHiddenInRecursion())
  361.                                 {
  362.                                         m_hiddenFlags |= eHideFlags_HiddenInRecursion;
  363.                                 }
  364.  
  365.                                 if (pAttachment->IsAttachmentHiddenInShadow())
  366.                                 {
  367.                                         m_hiddenFlags |= eHideFlags_HiddenInShadow;
  368.                                 }
  369.  
  370.                                 pAttachment->HideAttachment(1);
  371.                         }
  372.                 }
  373.         }
  374.  
  375.         virtual void OnExit(float blendTime)
  376.         {
  377.                 if (m_attachmentCRC != 0)
  378.                 {
  379.                         if (IAttachment* pAttachment = m_charInstance->GetIAttachmentManager()->GetInterfaceByNameCRC(m_attachmentCRC))
  380.                         {
  381.                                 pAttachment->HideAttachment((m_hiddenFlags & eHideFlags_HiddenInMainPass));
  382.                                 pAttachment->HideInRecursion((m_hiddenFlags & eHideFlags_HiddenInRecursion));
  383.                                 pAttachment->HideInShadow((m_hiddenFlags & eHideFlags_HiddenInShadow));
  384.                         }
  385.                 }
  386.         }
  387.  
  388.         virtual void Update(float timePassed) {}
  389.  
  390. private:
  391.         uint32 m_attachmentCRC;
  392.         uint32 m_hiddenFlags;
  393. };
  394.  
  395. REGISTER_PROCEDURAL_CLIP(CProceduralClipHideAttachment, "HideAttachment");
  396.  
downloadProceduralClipProps.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