BVB Source Codes

CRYENGINE Show ForceFeedbackSystem.h Source code

Return Download CRYENGINE: download ForceFeedbackSystem.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.  
  6.    Implementation for force feedback system
  7.  
  8. * Effect definition (shape, time, ...) are defined in xml
  9. * Effects are invoked by name, and updated here internally, feeding
  10.    input system in a per frame basis
  11.  
  12.    -------------------------------------------------------------------------
  13.    History:
  14.    - 18-02-2010:        Created by Benito Gangoso Rodriguez
  15.    - 20-09-2012: Updated by Dario Sancho (added support for Durango Triggers feedback)
  16.  
  17. *************************************************************************/
  18.  
  19. #pragma once
  20.  
  21. #ifndef _FORCEFEEDBACKSYSTEM_H_
  22.         #define _FORCEFEEDBACKSYSTEM_H_
  23.  
  24.         #include "../IForceFeedbackSystem.h"
  25.  
  26.         #define FFSYSTEM_MAX_PATTERN_SAMPLES        32
  27.         #define FFSYSTEM_MAX_PATTERN_SAMPLES_FLOAT  32.0f
  28.         #define FFSYSTEM_PATTERN_SAMPLE_STEP        0.03125f
  29.  
  30.         #define FFSYSTEM_MAX_ENVELOPE_SAMPLES       16
  31.         #define FFSYSTEM_MAX_ENVELOPE_SAMPLES_FLOAT 16.0f
  32.         #define FFSYSTEM_ENVELOPE_SAMPLE_STEP       0.0625f
  33.  
  34.         #define FFSYSTEM_UINT16_TO_FLOAT            0.0000152590218967f
  35.  
  36. struct SForceFeedbackSystemCVars
  37. {
  38.         SForceFeedbackSystemCVars();
  39.         ~SForceFeedbackSystemCVars();
  40.  
  41.         int ffs_debug;
  42. };
  43.  
  44. class CForceFeedBackSystem : public IForceFeedbackSystem
  45. {
  46. private:
  47.  
  48.         struct FFBInternalId
  49.         {
  50.                 FFBInternalId()
  51.                         : id(0)
  52.                 {
  53.  
  54.                 }
  55.  
  56.                 FFBInternalId(uint32 _id)
  57.                         : id(_id)
  58.                 {
  59.  
  60.                 }
  61.  
  62.                 FFBInternalId(const FFBInternalId& _otherId)
  63.                 {
  64.         #if defined(_DEBUG)
  65.                         name = _otherId.name;
  66.         #endif
  67.                         id = _otherId.id;
  68.                 }
  69.  
  70.                 void       Set(const char* _name);
  71.  
  72.                 ILINE bool operator==(const FFBInternalId& rhs) const
  73.                 {
  74.                         return (id == rhs.id);
  75.                 }
  76.  
  77.                 ILINE bool operator!=(const FFBInternalId& rhs) const
  78.                 {
  79.                         return (id != rhs.id);
  80.                 }
  81.  
  82.                 ILINE bool operator<(const FFBInternalId& rhs) const
  83.                 {
  84.                         return (id < rhs.id);
  85.                 }
  86.  
  87.                 ILINE bool operator>=(const FFBInternalId& rhs) const
  88.                 {
  89.                         return (id >= rhs.id);
  90.                 }
  91.  
  92.                 const char* GetDebugName() const;
  93.  
  94.                 //This is useful for look ups in debug, so we don't allocate strings
  95.                 static FFBInternalId& GetIdForName(const char* name);
  96.  
  97.         #if defined(_DEBUG)
  98.                 string name;
  99.         #endif
  100.                 uint32 id;
  101.         };
  102.  
  103.         struct SPattern
  104.         {
  105.                 float SamplePattern(float time) const
  106.                 {
  107.                         assert((time >= 0.0f) && (time <= 1.0f));
  108.  
  109.                         const float fSampleIdx = floor_tpl(time * (float)__fres(FFSYSTEM_PATTERN_SAMPLE_STEP));
  110.                         int sampleIdx1 = (int)fSampleIdx;
  111.                         assert((sampleIdx1 >= 0) && (sampleIdx1 < FFSYSTEM_MAX_PATTERN_SAMPLES));
  112.                         int sampleIdx2 = (sampleIdx1 >= (FFSYSTEM_MAX_PATTERN_SAMPLES - 1)) ? 0 : sampleIdx1 + 1;
  113.                         const float delta = clamp_tpl((FFSYSTEM_PATTERN_SAMPLE_STEP - (time - (FFSYSTEM_PATTERN_SAMPLE_STEP * fSampleIdx))) * FFSYSTEM_MAX_PATTERN_SAMPLES_FLOAT, 0.0f, 1.0f);
  114.  
  115.                         return ((SampleToFloat(sampleIdx1) * delta) + (SampleToFloat(sampleIdx2) * (1.0f - delta)));
  116.                 }
  117.  
  118.                 ILINE float SampleToFloat(int idx) const
  119.                 {
  120.                         return ((float)m_patternSamples[idx] * FFSYSTEM_UINT16_TO_FLOAT);
  121.                 }
  122.  
  123.                 ILINE void ResetToDefault()
  124.                 {
  125.                         memset(m_patternSamples, 0, sizeof(uint16) * FFSYSTEM_MAX_PATTERN_SAMPLES);
  126.                 }
  127.  
  128.                 ILINE bool operator<(const SPattern& rhs) const
  129.                 {
  130.                         return (m_patternId < rhs.m_patternId);
  131.                 }
  132.  
  133.                 uint16        m_patternSamples[FFSYSTEM_MAX_PATTERN_SAMPLES];
  134.                 FFBInternalId m_patternId;
  135.         };
  136.  
  137.         typedef std::vector<SPattern> TPatternsVector;
  138.  
  139.         struct SEnvelope
  140.         {
  141.                 float SampleEnvelope(float time) const
  142.                 {
  143.                         assert((time >= 0.0f) && (time <= 1.0f));
  144.  
  145.                         const float fSampleIdx = floor_tpl(time * (float)__fres(FFSYSTEM_ENVELOPE_SAMPLE_STEP));
  146.                         int sampleIdx1 = (int)fSampleIdx;
  147.                         sampleIdx1 = (sampleIdx1 >= (FFSYSTEM_MAX_ENVELOPE_SAMPLES - 1)) ? (FFSYSTEM_MAX_ENVELOPE_SAMPLES - 2) : sampleIdx1;
  148.                         int sampleIdx2 = sampleIdx1 + 1;
  149.                         const float delta = clamp_tpl((FFSYSTEM_ENVELOPE_SAMPLE_STEP - (time - (FFSYSTEM_ENVELOPE_SAMPLE_STEP * fSampleIdx))) * FFSYSTEM_MAX_ENVELOPE_SAMPLES_FLOAT, 0.0f, 1.0f);
  150.  
  151.                         return ((SampleToFloat(sampleIdx1) * delta) + (SampleToFloat(sampleIdx2) * (1.0f - delta)));
  152.                 }
  153.  
  154.                 ILINE float SampleToFloat(int idx) const
  155.                 {
  156.                         return ((float)m_envelopeSamples[idx] * FFSYSTEM_UINT16_TO_FLOAT);
  157.                 }
  158.  
  159.                 ILINE void ResetToDefault()
  160.                 {
  161.                         memset(m_envelopeSamples, 0, sizeof(uint16) * FFSYSTEM_MAX_ENVELOPE_SAMPLES);
  162.                 }
  163.  
  164.                 ILINE bool operator<(const SEnvelope& rhs) const
  165.                 {
  166.                         return (m_envelopeId < rhs.m_envelopeId);
  167.                 }
  168.  
  169.                 uint16        m_envelopeSamples[FFSYSTEM_MAX_ENVELOPE_SAMPLES];
  170.                 FFBInternalId m_envelopeId;
  171.         };
  172.  
  173.         typedef std::vector<SEnvelope> TEnvelopesVector;
  174.  
  175.         struct SEffect
  176.         {
  177.                 SEffect()
  178.                         : time(1.0f)
  179.                         , frequencyA(1.0f)
  180.                         , frequencyB(1.0f)
  181.                         , frequencyLT(0.0f)
  182.                         , frequencyRT(0.0f)
  183.                 {
  184.  
  185.                 }
  186.  
  187.                 FFBInternalId patternA;
  188.                 FFBInternalId envelopeA;
  189.                 FFBInternalId patternB;
  190.                 FFBInternalId envelopeB;
  191.                 FFBInternalId patternLT;
  192.                 FFBInternalId envelopeLT;
  193.                 FFBInternalId patternRT;
  194.                 FFBInternalId envelopeRT;
  195.  
  196.                 float         frequencyA;
  197.                 float         frequencyB;
  198.                 float         frequencyLT;
  199.                 float         frequencyRT;
  200.                 float         time;
  201.         };
  202.  
  203.         typedef VectorMap<FFBInternalId, ForceFeedbackFxId> TEffectToIndexMap;
  204.         typedef std::vector<SEffect>                        TEffectArray;
  205.  
  206.         struct SFFOutput
  207.         {
  208.                 SFFOutput()
  209.                         : forceFeedbackA(0.0f)
  210.                         , forceFeedbackB(0.0f)
  211.                         , forceFeedbackLT(0.0f)
  212.                         , forceFeedbackRT(0.0f)
  213.                 {
  214.  
  215.                 }
  216.  
  217.                 void operator+=(const SFFOutput& operand2)
  218.                 {
  219.                         forceFeedbackA += operand2.forceFeedbackA;
  220.                         forceFeedbackB += operand2.forceFeedbackB;
  221.                         forceFeedbackLT += operand2.forceFeedbackLT;
  222.                         forceFeedbackRT += operand2.forceFeedbackRT;
  223.                 }
  224.  
  225.                 ILINE float GetClampedFFA() const
  226.                 {
  227.                         return clamp_tpl(forceFeedbackA, 0.0f, 1.0f);
  228.                 }
  229.  
  230.                 ILINE float GetClampedFFB() const
  231.                 {
  232.                         return clamp_tpl(forceFeedbackB, 0.0f, 1.0f);
  233.                 }
  234.  
  235.                 ILINE float GetClampedFFLT() const
  236.                 {
  237.                         return clamp_tpl(forceFeedbackLT, 0.0f, 1.0f);
  238.                 }
  239.  
  240.                 ILINE float GetClampedFFRT() const
  241.                 {
  242.                         return clamp_tpl(forceFeedbackRT, 0.0f, 1.0f);
  243.                 }
  244.  
  245.                 ILINE void ZeroIt()
  246.                 {
  247.                         forceFeedbackA = forceFeedbackB = forceFeedbackLT = forceFeedbackRT = 0.0f;
  248.                 }
  249.  
  250.                 float forceFeedbackA;
  251.                 float forceFeedbackB;
  252.                 float forceFeedbackLT;
  253.                 float forceFeedbackRT;
  254.         };
  255.  
  256.         struct SActiveEffect
  257.         {
  258.                 SActiveEffect()
  259.                         : effectId(InvalidForceFeedbackFxId)
  260.                         , effectTime(1.0f)
  261.                         , runningTime(0.0f)
  262.                         , frequencyA(1.0f)
  263.                         , frequencyB(1.0f)
  264.                 {
  265.  
  266.                 }
  267.  
  268.                 ILINE bool HasFinished() const
  269.                 {
  270.                         return (effectTime > 0.0f) ? (runningTime > effectTime) : false;
  271.                 }
  272.  
  273.                 SFFOutput Update(float frameTime);
  274.  
  275.                 ForceFeedbackFxId           effectId;
  276.                 SForceFeedbackRuntimeParams runtimeParams;
  277.                 float                       effectTime;
  278.                 float                       runningTime;
  279.                 float                       frequencyA;
  280.                 float                       frequencyB;
  281.                 float                       frequencyLT;
  282.                 float                       frequencyRT;
  283.                 SPattern                    m_patternA;
  284.                 SEnvelope                   m_envelopeA;
  285.                 SPattern                    m_patternB;
  286.                 SEnvelope                   m_envelopeB;
  287.                 SPattern                    m_patternLT;
  288.                 SEnvelope                   m_envelopeLT;
  289.                 SPattern                    m_patternRT;
  290.                 SEnvelope                   m_envelopeRT;
  291.         };
  292.  
  293.         typedef std::vector<SActiveEffect> TActiveEffectsArray;
  294.         typedef std::vector<string>        TEffectNamesArray;
  295.  
  296.         typedef CryFixedStringT<256>       TSamplesBuffer;
  297.  
  298. public:
  299.  
  300.         CForceFeedBackSystem();
  301.         ~CForceFeedBackSystem();
  302.  
  303.         //IForceFeedbackSystem
  304.         virtual void              PlayForceFeedbackEffect(ForceFeedbackFxId id, const SForceFeedbackRuntimeParams& runtimeParams) override;
  305.         virtual void              StopForceFeedbackEffect(ForceFeedbackFxId id) override;
  306.         virtual void              StopAllEffects() override;
  307.  
  308.         virtual ForceFeedbackFxId GetEffectIdByName(const char* effectName) const override;
  309.  
  310.         virtual void              AddFrameCustomForceFeedback(const float amplifierA, const float amplifierB, const float amplifierLT = 0.0f, const float amplifierRT = 0.0f) override;
  311.         virtual void              AddCustomTriggerForceFeedback(const SFFTriggerOutputData& triggersData) override;
  312.  
  313.         virtual void              EnumerateEffects(IFFSPopulateCallBack* pCallBack) override; // intended to be used only from the editor
  314.         virtual int               GetEffectNamesCount() const override;
  315.         virtual void              SuppressEffects(bool bSuppressEffects) override;
  316.         //~IForceFeedbackSystem
  317.  
  318.         void Initialize();
  319.         void Reload();
  320.  
  321.         void Update(float frameTime);
  322.  
  323. private:
  324.  
  325.         bool             TryToRestartEffectIfAlreadyRunning(ForceFeedbackFxId id, const SForceFeedbackRuntimeParams& runtimeParams);
  326.  
  327.         void             LoadXmlData();
  328.  
  329.         void             LoadPatters(XmlNodeRef& patternsNode);
  330.         void             LoadEnvelopes(XmlNodeRef& envelopesNode);
  331.         void             LoadEffects(XmlNodeRef& effectsNode);
  332.  
  333.         int              ParseSampleBuffer(const TSamplesBuffer& buffer, float* outputValues, const int maxOutputValues);
  334.         void             DistributeSamples(const float* sampleInput, const int sampleInputCount, uint16* sampleOutput, const int sampleOutputCount);
  335.  
  336.         void             UpdateInputSystem(const float amplifierA, const float amplifierB, const SFFTriggerOutputData& triggers);
  337.  
  338.         const SPattern&  FindPattern(const FFBInternalId& id) const;
  339.         const SEnvelope& FindEnvelope(const FFBInternalId& id) const;
  340.  
  341.         SPattern                  m_defaultPattern;
  342.         SEnvelope                 m_defaultEnvelope;
  343.  
  344.         TPatternsVector           m_patters;
  345.         TEnvelopesVector          m_envelopes;
  346.  
  347.         TEffectToIndexMap         m_effectToIndexMap;
  348.         TEffectArray              m_effects;
  349.         TActiveEffectsArray       m_activeEffects;
  350.  
  351.         TEffectNamesArray         m_effectNames; //Stored list of names for Flow graph system UI
  352.  
  353.         SFFOutput                 m_frameCustomForceFeedback;
  354.         SFFTriggerOutputData      m_triggerCustomForceFeedBack;
  355.  
  356.         SForceFeedbackSystemCVars m_cvars;
  357.         int                       m_effectLock;
  358. };
  359. #endif
  360.  
downloadForceFeedbackSystem.h 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