BVB Source Codes

CRYENGINE Show FlowAudioTriggerNode.cpp Source code

Return Download CRYENGINE: download FlowAudioTriggerNode.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 <CryFlowGraph/IFlowBaseNode.h>
  5.  
  6. class CFlowNode_AudioTrigger final : public CFlowBaseNode<eNCT_Instanced>
  7. {
  8. public:
  9.  
  10.         explicit CFlowNode_AudioTrigger(SActivationInfo* pActInfo)
  11.                 : m_flags(eFlowNodeAudioTriggerFlags_None)
  12.                 , m_playTriggerId(INVALID_AUDIO_CONTROL_ID)
  13.                 , m_stopTriggerId(INVALID_AUDIO_CONTROL_ID)
  14.         {}
  15.  
  16.         //////////////////////////////////////////////////////////////////////////
  17.         virtual ~CFlowNode_AudioTrigger() override
  18.         {
  19.                 if ((m_flags & eFlowNodeAudioTriggerFlags_IsListener) > 0)
  20.                 {
  21.                         RemoveRequestListener();
  22.                 }
  23.         }
  24.  
  25.         CFlowNode_AudioTrigger(CFlowNode_AudioTrigger const&) = delete;
  26.         CFlowNode_AudioTrigger(CFlowNode_AudioTrigger&&) = delete;
  27.         CFlowNode_AudioTrigger& operator=(CFlowNode_AudioTrigger const&) = delete;
  28.         CFlowNode_AudioTrigger& operator=(CFlowNode_AudioTrigger&&) = delete;
  29.  
  30.         //////////////////////////////////////////////////////////////////////////
  31.         virtual IFlowNodePtr Clone(SActivationInfo* pActInfo) override
  32.         {
  33.                 return new CFlowNode_AudioTrigger(pActInfo);
  34.         }
  35.  
  36.         //////////////////////////////////////////////////////////////////////////
  37.         enum INPUTS
  38.         {
  39.                 eIn_PlayTrigger,
  40.                 eIn_StopTrigger,
  41.                 eIn_Play,
  42.                 eIn_Stop,
  43.         };
  44.  
  45.         enum OUTPUTS
  46.         {
  47.                 eOut_Done,
  48.         };
  49.  
  50.         virtual void GetConfiguration(SFlowNodeConfig& config) override
  51.         {
  52.                 static const SInputPortConfig inputs[] =
  53.                 {
  54.                         InputPortConfig<string>("audioTrigger_PlayTrigger", _HELP("name of the Play Trigger"),                                                                        "PlayTrigger"),
  55.                         InputPortConfig<string>("audioTrigger_StopTrigger", _HELP("name of the Stop Trigger"),                                                                        "StopTrigger"),
  56.  
  57.                         InputPortConfig_Void("Play",                        _HELP("Executes the Play Trigger")),
  58.                         InputPortConfig_Void("Stop",                        _HELP("Executes the Stop Trigger if it is provided, o/w stops all events started by the Start Trigger")),
  59.                         { 0 }
  60.                 };
  61.  
  62.                 static const SOutputPortConfig outputs[] =
  63.                 {
  64.                         OutputPortConfig_Void("Done", _HELP("Activated when all of the triggered events have finished playing")),
  65.                         { 0 }
  66.                 };
  67.  
  68.                 config.pInputPorts = inputs;
  69.                 config.pOutputPorts = outputs;
  70.                 config.sDescription = _HELP("This node executes Audio Triggers.");
  71.                 config.nFlags |= EFLN_TARGET_ENTITY;
  72.                 config.SetCategory(EFLN_APPROVED);
  73.         }
  74.  
  75.         //////////////////////////////////////////////////////////////////////////
  76.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser) override
  77.         {
  78.                 bool bPlay = ((m_flags & eFlowNodeAudioTriggerFlags_IsPlaying) > 0);
  79.                 ser.BeginGroup("FlowAudioTriggerNode");
  80.                 ser.Value("play", bPlay);
  81.                 ser.EndGroup();
  82.  
  83.                 if (ser.IsReading())
  84.                 {
  85.                         Init(pActInfo, bPlay);
  86.                 }
  87.         }
  88.  
  89.         //////////////////////////////////////////////////////////////////////////
  90.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo) override
  91.         {
  92.                 switch (event)
  93.                 {
  94.                 case eFE_Initialize:
  95.                         {
  96.                                 Stop(pActInfo->pEntity);
  97.                                 Init(pActInfo, false);
  98.  
  99.                                 break;
  100.                         }
  101.                 case eFE_ConnectOutputPort:
  102.                         {
  103.                                 if ((m_flags & eFlowNodeAudioTriggerFlags_IsListener) == 0)
  104.                                 {
  105.                                         AddRequestListener();
  106.                                 }
  107.  
  108.                                 break;
  109.                         }
  110.                 case eFE_DisconnectOutputPort:
  111.                         {
  112.                                 if ((m_flags & eFlowNodeAudioTriggerFlags_IsListener) > 0)
  113.                                 {
  114.                                         RemoveRequestListener();
  115.                                 }
  116.  
  117.                                 break;
  118.                         }
  119.                 case eFE_Activate:
  120.                         {
  121.                                 if (IsPortActive(pActInfo, eIn_Stop))
  122.                                 {
  123.                                         Stop(pActInfo->pEntity);
  124.                                 }
  125.  
  126.                                 if (IsPortActive(pActInfo, eIn_Play))
  127.                                 {
  128.                                         m_playActivationInfo = *pActInfo;
  129.                                         Play(pActInfo->pEntity);
  130.                                 }
  131.  
  132.                                 if (IsPortActive(pActInfo, eIn_PlayTrigger))
  133.                                 {
  134.                                         Stop(pActInfo->pEntity);
  135.                                         GetTriggerID(pActInfo, eIn_PlayTrigger, m_playTriggerId);
  136.                                 }
  137.  
  138.                                 if (IsPortActive(pActInfo, eIn_StopTrigger))
  139.                                 {
  140.                                         GetTriggerID(pActInfo, eIn_StopTrigger, m_stopTriggerId);
  141.                                 }
  142.  
  143.                                 break;
  144.                         }
  145.                 }
  146.         }
  147.  
  148.         //////////////////////////////////////////////////////////////////////////
  149.         virtual void GetMemoryUsage(ICrySizer* s) const override
  150.         {
  151.                 s->Add(*this);
  152.         }
  153.  
  154.         //////////////////////////////////////////////////////////////////////////
  155.         void TriggerFinished(AudioControlId const audioTriggerId)
  156.         {
  157.                 if (audioTriggerId == m_playTriggerId)
  158.                 {
  159.                         ActivateOutput(&m_playActivationInfo, eOut_Done, true);
  160.                 }
  161.         }
  162.  
  163. private:
  164.  
  165.         enum EPlayMode : AudioEnumFlagsType
  166.         {
  167.                 ePlayMode_None      = 0,
  168.                 ePlayMode_Play      = 1,
  169.                 ePlayMode_PlayStop  = 2,
  170.                 ePlayMode_ForceStop = 3,
  171.         };
  172.  
  173.         enum EFlowNodeAudioTriggerFlags : AudioEnumFlagsType
  174.         {
  175.                 eFlowNodeAudioTriggerFlags_None       = 0,
  176.                 eFlowNodeAudioTriggerFlags_IsPlaying  = BIT(0),
  177.                 eFlowNodeAudioTriggerFlags_IsListener = BIT(1),
  178.         };
  179.  
  180.         //////////////////////////////////////////////////////////////////////////
  181.         static void OnAudioTriggerFinished(SAudioRequestInfo const* const pAudioRequestInfo)
  182.         {
  183.                 TFlowGraphId const id = static_cast<TFlowGraphId>(reinterpret_cast<UINT_PTR>(pAudioRequestInfo->pUserData));
  184.  
  185.                 if (gEnv->pFlowSystem->GetGraphById(id) != nullptr)
  186.                 {
  187.                         // Here we are sure that this FlowGraphNode is still valid.
  188.                         CFlowNode_AudioTrigger* const pAudioTrigger = static_cast<CFlowNode_AudioTrigger*>(pAudioRequestInfo->pOwner);
  189.                         pAudioTrigger->TriggerFinished(pAudioRequestInfo->audioControlId);
  190.                 }
  191.         }
  192.  
  193.         //////////////////////////////////////////////////////////////////////////
  194.         void GetTriggerID(SActivationInfo* const pActInfo, uint32 const portIndex, AudioControlId& outAudioTriggerId)
  195.         {
  196.                 outAudioTriggerId = INVALID_AUDIO_CONTROL_ID;
  197.                 string const& audioTriggerName = GetPortString(pActInfo, portIndex);
  198.  
  199.                 if (!audioTriggerName.empty())
  200.                 {
  201.                         gEnv->pAudioSystem->GetAudioTriggerId(audioTriggerName.c_str(), outAudioTriggerId);
  202.                 }
  203.         }
  204.  
  205.         //////////////////////////////////////////////////////////////////////////
  206.         void Init(SActivationInfo* const pActInfo, bool const bPlay)
  207.         {
  208.                 m_flags &= ~eFlowNodeAudioTriggerFlags_IsPlaying;
  209.  
  210.                 if (gEnv->pAudioSystem != nullptr)
  211.                 {
  212.                         GetTriggerID(pActInfo, eIn_PlayTrigger, m_playTriggerId);
  213.                         GetTriggerID(pActInfo, eIn_StopTrigger, m_stopTriggerId);
  214.                 }
  215.  
  216.                 if (IsOutputConnected(pActInfo, eOut_Done))
  217.                 {
  218.                         if ((m_flags & eFlowNodeAudioTriggerFlags_IsListener) == 0)
  219.                         {
  220.                                 AddRequestListener();
  221.                         }
  222.                 }
  223.                 else if ((m_flags & eFlowNodeAudioTriggerFlags_IsListener) > 0)
  224.                 {
  225.                         RemoveRequestListener();
  226.                 }
  227.         }
  228.  
  229.         //////////////////////////////////////////////////////////////////////////
  230.         void ExecuteOnProxy(IEntity* const pIEntity, AudioControlId const audioTriggerId, EPlayMode const playMode)
  231.         {
  232.                 IEntityAudioComponent* const pIEntityAudioComponent = pIEntity->GetOrCreateComponent<IEntityAudioComponent>();
  233.  
  234.                 if (pIEntityAudioComponent != nullptr)
  235.                 {
  236.                         switch (playMode)
  237.                         {
  238.                         case ePlayMode_Play:
  239.                                 {
  240.                                         SAudioCallBackInfo const callbackInfo(this, reinterpret_cast<void*>(static_cast<UINT_PTR>(m_playActivationInfo.pGraph->GetGraphId())), this, eAudioRequestFlags_PriorityNormal | eAudioRequestFlags_SyncFinishedCallback);
  241.                                         pIEntityAudioComponent->SetCurrentEnvironments();
  242.                                         pIEntityAudioComponent->ExecuteTrigger(audioTriggerId, DEFAULT_AUDIO_PROXY_ID, callbackInfo);
  243.  
  244.                                         break;
  245.                                 }
  246.                         case ePlayMode_PlayStop:
  247.                                 {
  248.                                         pIEntityAudioComponent->SetCurrentEnvironments();
  249.                                         pIEntityAudioComponent->ExecuteTrigger(audioTriggerId);
  250.  
  251.                                         break;
  252.                                 }
  253.                         case ePlayMode_ForceStop:
  254.                                 {
  255.                                         pIEntityAudioComponent->StopTrigger(audioTriggerId);
  256.  
  257.                                         break;
  258.                                 }
  259.                         default:
  260.                                 {
  261.                                         assert(false);// Unknown play mode!
  262.                                 }
  263.                         }
  264.                 }
  265.         }
  266.  
  267.         //////////////////////////////////////////////////////////////////////////
  268.         void ExecuteOnGlobalObject(AudioControlId const audioTriggerId, EPlayMode const playMode)
  269.         {
  270.                 switch (playMode)
  271.                 {
  272.                 case ePlayMode_Play:
  273.                         {
  274.                                 m_executeRequestData.audioTriggerId = audioTriggerId;
  275.                                 m_request.pOwner = this;
  276.                                 m_request.pData = &m_executeRequestData;
  277.                                 gEnv->pAudioSystem->PushRequest(m_request);
  278.  
  279.                                 break;
  280.                         }
  281.                 case ePlayMode_PlayStop:
  282.                         {
  283.                                 m_executeRequestData.audioTriggerId = audioTriggerId;
  284.                                 m_request.pData = &m_executeRequestData;
  285.                                 gEnv->pAudioSystem->PushRequest(m_request);
  286.  
  287.                                 break;
  288.                         }
  289.                 case ePlayMode_ForceStop:
  290.                         {
  291.                                 m_stopRequestData.audioTriggerId = audioTriggerId;
  292.                                 m_request.pData = &m_stopRequestData;
  293.                                 gEnv->pAudioSystem->PushRequest(m_request);
  294.  
  295.                                 break;
  296.                         }
  297.                 default:
  298.                         {
  299.                                 assert(false);// Unknown play mode!
  300.                         }
  301.                 }
  302.         }
  303.  
  304.         //////////////////////////////////////////////////////////////////////////
  305.         void Play(IEntity* const pIEntity)
  306.         {
  307.                 if (m_playTriggerId != INVALID_AUDIO_CONTROL_ID)
  308.                 {
  309.                         if (pIEntity != nullptr)
  310.                         {
  311.                                 ExecuteOnProxy(pIEntity, m_playTriggerId, ePlayMode_Play);
  312.                         }
  313.                         else
  314.                         {
  315.                                 ExecuteOnGlobalObject(m_playTriggerId, ePlayMode_Play);
  316.                         }
  317.  
  318.                         m_flags |= eFlowNodeAudioTriggerFlags_IsPlaying;
  319.                 }
  320.         }
  321.  
  322.         //////////////////////////////////////////////////////////////////////////
  323.         void Stop(IEntity* const pIEntity)
  324.         {
  325.                 if ((m_flags & eFlowNodeAudioTriggerFlags_IsPlaying) > 0)
  326.                 {
  327.                         if (m_stopTriggerId != INVALID_AUDIO_CONTROL_ID)
  328.                         {
  329.                                 if (pIEntity != nullptr)
  330.                                 {
  331.                                         ExecuteOnProxy(pIEntity, m_stopTriggerId, ePlayMode_PlayStop);
  332.                                 }
  333.                                 else
  334.                                 {
  335.                                         ExecuteOnGlobalObject(m_stopTriggerId, ePlayMode_PlayStop);
  336.                                 }
  337.                         }
  338.                         else
  339.                         {
  340.                                 if (pIEntity != nullptr)
  341.                                 {
  342.                                         ExecuteOnProxy(pIEntity, m_playTriggerId, ePlayMode_ForceStop);
  343.                                 }
  344.                                 else
  345.                                 {
  346.                                         ExecuteOnGlobalObject(m_playTriggerId, ePlayMode_ForceStop);
  347.                                 }
  348.                         }
  349.  
  350.                         m_flags &= ~eFlowNodeAudioTriggerFlags_IsPlaying;
  351.                 }
  352.         }
  353.  
  354.         //////////////////////////////////////////////////////////////////////////
  355.         void AddRequestListener()
  356.         {
  357.                 SAudioManagerRequestData<eAudioManagerRequestType_AddRequestListener> requestData(this, &CFlowNode_AudioTrigger::OnAudioTriggerFinished, eAudioRequestType_AudioCallbackManagerRequest, eAudioCallbackManagerRequestType_ReportFinishedTriggerInstance);
  358.                 SAudioRequest request;
  359.                 request.flags = eAudioRequestFlags_PriorityHigh;
  360.                 request.pOwner = this;
  361.                 request.pData = &requestData;
  362.                 gEnv->pAudioSystem->PushRequest(request);
  363.                 m_flags |= eFlowNodeAudioTriggerFlags_IsListener;
  364.         }
  365.  
  366.         //////////////////////////////////////////////////////////////////////////
  367.         void RemoveRequestListener()
  368.         {
  369.                 SAudioManagerRequestData<eAudioManagerRequestType_RemoveRequestListener> requestData(this, &CFlowNode_AudioTrigger::OnAudioTriggerFinished);
  370.                 SAudioRequest request;
  371.                 request.flags = eAudioRequestFlags_PriorityHigh;
  372.                 request.pOwner = this;
  373.                 request.pData = &requestData;
  374.                 gEnv->pAudioSystem->PushRequest(request);
  375.                 m_flags &= ~eFlowNodeAudioTriggerFlags_IsListener;
  376.         }
  377.  
  378.         //////////////////////////////////////////////////////////////////////////
  379.         AudioEnumFlagsType m_flags;
  380.         AudioControlId     m_playTriggerId;
  381.         AudioControlId     m_stopTriggerId;
  382.         SActivationInfo    m_playActivationInfo;
  383.         SAudioRequest      m_request;
  384.         SAudioObjectRequestData<eAudioObjectRequestType_ExecuteTrigger> m_executeRequestData;
  385.         SAudioObjectRequestData<eAudioObjectRequestType_StopTrigger>    m_stopRequestData;
  386. };
  387.  
  388. REGISTER_FLOW_NODE("Audio:Trigger", CFlowNode_AudioTrigger);
  389.  
downloadFlowAudioTriggerNode.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