BVB Source Codes

CRYENGINE Show ControllerPQ.h Source code

Return Download CRYENGINE: download ControllerPQ.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #pragma once
  4.  
  5. #include <Cry3DEngine/CGF/CGFContent.h>
  6. #include "QuatQuantization.h"
  7. #include "ControllerDefragHeap.h"
  8.  
  9. class IControllerOpt;
  10. class IKeyTimesInformation;
  11. class IPositionController;
  12. class IRotationController;
  13. class ITrackPositionStorage;
  14. class ITrackRotationStorage;
  15.  
  16. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  17. namespace ControllerHelper
  18. {
  19. uint32 GetPositionsFormatSizeOf(uint32 format);
  20. uint32 GetRotationFormatSizeOf(uint32 format);
  21. uint32 GetScalingFormatSizeOf(uint32 format);
  22. uint32 GetKeyTimesFormatSizeOf(uint32 format);
  23.  
  24. // TODO: Rename following methods to "construct".
  25. ITrackPositionStorage* GetPositionControllerPtr(uint32 format, void* pData = NULL, size_t numElements = 0);
  26. ITrackRotationStorage* GetRotationControllerPtr(uint32 format, void* pData = NULL, size_t numElements = 0);
  27. ITrackPositionStorage* GetScalingControllerPtr(uint32 format, void* pData = NULL, size_t numElements = 0);
  28. IKeyTimesInformation*  GetKeyTimesControllerPtr(uint32 format, void* pData = NULL, size_t numElements = 0);
  29.  
  30. extern const uint8 m_byteTable[256];
  31. extern const uint8 m_byteLowBit[256];
  32. extern const uint8 m_byteHighBit[256];
  33. }
  34.  
  35. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  36. extern CControllerDefragHeap g_controllerHeap;
  37.  
  38. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  39. class IControllerRelocatableChain
  40. {
  41. public:
  42.  
  43.         virtual void Relocate(char* pDst, char* pSrc) = 0;
  44.  
  45.         IControllerRelocatableChain()
  46.                 : m_pNext(nullptr)
  47.         {
  48.         }
  49.  
  50.         void                         LinkTo(IControllerRelocatableChain* pNext) { m_pNext = pNext; }
  51.  
  52.         IControllerRelocatableChain* GetNext() const                            { return m_pNext; }
  53.  
  54. protected:
  55.  
  56.         virtual ~IControllerRelocatableChain() {}
  57.  
  58. private:
  59.  
  60.         IControllerRelocatableChain* m_pNext;
  61. };
  62.  
  63. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  64. enum EKeyTimesFormat
  65. {
  66.         // Don't add values which increase the maximum enum value over 255 because this will break IControllerOptNonVirtual!!!!
  67.         eF32 = 0,
  68.         eUINT16,
  69.         eByte,
  70.         eF32StartStop,
  71.         eUINT16StartStop,
  72.         eByteStartStop,
  73.         eBitset,
  74.         eNoFormat = 255
  75. };
  76.  
  77. struct F32Encoder
  78. {
  79.         typedef f32    TKeyTypeTraits;
  80.         typedef uint32 TKeyTypeCountTraits;
  81.  
  82.         static EKeyTimesFormat GetFormat() { return eF32; };
  83. };
  84.  
  85. struct UINT16Encoder
  86. {
  87.         typedef uint16 TKeyTypeTraits;
  88.         typedef uint16 TKeyTypeCountTraits;
  89.  
  90.         static EKeyTimesFormat GetFormat() { return eUINT16; };
  91. };
  92.  
  93. struct ByteEncoder
  94. {
  95.         typedef uint8  TKeyTypeTraits;
  96.         typedef uint16 TKeyTypeCountTraits;
  97.  
  98.         static EKeyTimesFormat GetFormat() { return eByte; };
  99. };
  100.  
  101. struct F32StartStopEncoder
  102. {
  103.         static EKeyTimesFormat GetFormat() { return eF32StartStop; };
  104. };
  105.  
  106. struct UINT16StartStopEncoder
  107. {
  108.         static EKeyTimesFormat GetFormat() { return eUINT16StartStop; };
  109. };
  110.  
  111. struct ByteStartStopEncoder
  112. {
  113.         static EKeyTimesFormat GetFormat() { return eByteStartStop; };
  114. };
  115.  
  116. struct BitsetEncoder
  117. {
  118.         typedef uint16 TKeyTypeTraits;
  119.         typedef uint16 TKeyTypeCountTraits;
  120.  
  121.         static EKeyTimesFormat GetFormat() { return eBitset; };
  122. };
  123.  
  124. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  125. class IKeyTimesInformation : public _reference_target_t
  126. {
  127. public:
  128.  
  129.         virtual ~IKeyTimesInformation() {}
  130.  
  131.         // return key value in f32 format
  132.         virtual f32 GetKeyValueFloat(uint32 key) const = 0;
  133.  
  134.         // return key number for normalized_time
  135.         virtual uint32                       GetKey(f32 normalized_time, f32& difference_time) = 0;
  136.  
  137.         virtual uint32                       GetNumKeys() const = 0;
  138.  
  139.         virtual uint32                       AssignKeyTime(const char* pData, uint32 numElements) = 0;
  140.  
  141.         virtual uint32                       GetFormat() = 0;
  142.  
  143.         virtual char*                        GetData() = 0;
  144.  
  145.         virtual uint32                       GetDataRawSize() = 0;
  146.  
  147.         virtual IControllerRelocatableChain* GetRelocateChain() = 0;
  148. };
  149.  
  150. template<class TKeyTime, class TEncoder>
  151. class CKeyTimesInformation : public IKeyTimesInformation, public IControllerRelocatableChain
  152. {
  153. public:
  154.  
  155.         typedef TKeyTime KeyTimeType;
  156.  
  157.         CKeyTimesInformation()
  158.                 : m_pKeys(nullptr)
  159.                 , m_numKeys(0)
  160.                 , m_lastTime(-1)
  161.         {
  162.         }
  163.  
  164.         CKeyTimesInformation(TKeyTime* pKeys, uint32 numKeys)
  165.                 : m_pKeys(pKeys)
  166.                 , m_numKeys(numKeys | (numKeys > 0 ? kKeysConstantMask : 0))
  167.                 , m_lastTime(-1)
  168.         {
  169.         }
  170.  
  171.         ~CKeyTimesInformation()
  172.         {
  173.                 if (!IsConstant() && m_hHdl.IsValid())
  174.                         g_controllerHeap.Free(m_hHdl);
  175.         }
  176.  
  177.         // return key value
  178.         TKeyTime GetKeyValue(uint32 key) const { return m_pKeys[key]; };
  179.  
  180.         // return key value in f32 format
  181.         f32 GetKeyValueFloat(uint32 key) const { return (m_pKeys[key]); }
  182.  
  183.         // return key number for normalized_time
  184.         uint32 GetKey(f32 normalized_time, f32& difference_time)
  185.         {
  186.                 TKeyTime* pKeys = m_pKeys;
  187.                 uint32 numKey = GetNumKeys_Int();
  188.  
  189.                 f32 realtime = normalized_time;
  190.  
  191.                 /*
  192.                    if (realtime == m_lastTime)
  193.                    {
  194.                    difference_time =  m_LastDifferenceTime;
  195.                    return m_lastKey;
  196.                    }*/
  197.  
  198.                 m_lastTime = realtime;
  199.  
  200.                 TKeyTime keytime_start = pKeys[0];
  201.                 TKeyTime keytime_end = pKeys[numKey - 1];
  202.  
  203.                 f32 test_end = keytime_end;
  204.                 if (realtime < keytime_start)
  205.                         test_end += realtime;
  206.  
  207.                 if (realtime < keytime_start)
  208.                 {
  209.                         m_lastKey = 0;
  210.                         return 0;
  211.                 }
  212.  
  213.                 if (realtime >= keytime_end)
  214.                 {
  215.                         m_lastKey = numKey;
  216.                         return numKey;
  217.                 }
  218.  
  219.                 int nPos = numKey >> 1;
  220.                 int nStep = numKey >> 2;
  221.  
  222.                 // use binary search
  223.                 while (nStep)
  224.                 {
  225.                         if (realtime < pKeys[nPos])
  226.                                 nPos = nPos - nStep;
  227.                         else if (realtime > pKeys[nPos])
  228.                                 nPos = nPos + nStep;
  229.                         else
  230.                                 break;
  231.  
  232.                         nStep = nStep >> 1;
  233.                 }
  234.  
  235.                 // fine-tuning needed since time is not linear
  236.                 while (realtime > pKeys[nPos])
  237.                         nPos++;
  238.  
  239.                 while (realtime < pKeys[nPos - 1])
  240.                         nPos--;
  241.  
  242.                 m_lastKey = nPos;
  243.  
  244.                 // possible error if encoder uses nonlinear methods!!!
  245.                 m_LastDifferenceTime = difference_time = /*TEncoder::DecodeKeyValue*/ (f32)(realtime - (f32)pKeys[nPos - 1]) / ((f32)pKeys[nPos] - (f32)pKeys[nPos - 1]);
  246.  
  247.                 return nPos;
  248.  
  249.         }
  250.  
  251.         uint32 GetNumKeys() const { return GetNumKeys_Int(); };
  252.  
  253.         uint32 AssignKeyTime(const char* pData, uint32 numElements)
  254.         {
  255. #ifndef _RELEASE
  256.                 if (IsConstant())
  257.                 {
  258.                         __debugbreak();
  259.                         return 0;
  260.                 }
  261. #endif
  262.  
  263.                 if (m_hHdl.IsValid())
  264.                         g_controllerHeap.Free(m_hHdl);
  265.  
  266.                 uint32 sz = numElements * sizeof(TKeyTime);
  267.  
  268.                 this->LinkTo(NULL);
  269.                 CControllerDefragHdl hdl = g_controllerHeap.AllocPinned(sz, this);
  270.                 m_pKeys = (TKeyTime*)g_controllerHeap.WeakPin(hdl);
  271.                 m_hHdl = hdl;
  272.                 m_numKeys = numElements;
  273.  
  274.                 memcpy(m_pKeys, pData, sz);
  275.                 g_controllerHeap.Unpin(hdl);
  276.  
  277.                 return sz;
  278.         }
  279.  
  280.         uint32 GetFormat()
  281.         {
  282.                 return TEncoder::GetFormat();
  283.         }
  284.  
  285.         char* GetData()
  286.         {
  287.                 return (char*) m_pKeys;
  288.         }
  289.  
  290.         uint32 GetDataRawSize()
  291.         {
  292.                 return GetNumKeys_Int() * sizeof(TKeyTime);
  293.         }
  294.  
  295.         IControllerRelocatableChain* GetRelocateChain()
  296.         {
  297.                 return this;
  298.         }
  299.  
  300.         void Relocate(char* pDst, char* pSrc)
  301.         {
  302.                 ptrdiff_t offs = reinterpret_cast<char*>(m_pKeys) - pSrc;
  303.                 m_pKeys = reinterpret_cast<TKeyTime*>(pDst + offs);
  304.         }
  305.  
  306. private:
  307.  
  308.         CKeyTimesInformation(const CKeyTimesInformation<TKeyTime, TEncoder>&);  //= delete;
  309.         void operator=(const CKeyTimesInformation<TKeyTime, TEncoder>&);        //= delete;
  310.  
  311.         enum
  312.         {
  313.                 kKeysSizeMask     = 0x7fffffff,
  314.                 kKeysConstantMask = 0x80000000,
  315.         };
  316.  
  317.         ILINE uint32 IsConstant() const     { return m_numKeys & kKeysConstantMask; }
  318.         ILINE uint32 GetNumKeys_Int() const { return m_numKeys & kKeysSizeMask; }
  319.  
  320.         TKeyTime*            m_pKeys;
  321.         CControllerDefragHdl m_hHdl;
  322.         uint32               m_numKeys;
  323.         f32                  m_lastTime;
  324.         f32                  m_LastDifferenceTime;
  325.         uint32               m_lastKey;
  326. };
  327.  
  328. typedef CKeyTimesInformation<f32, F32Encoder>       F32KeyTimesInformation;
  329. typedef CKeyTimesInformation<uint16, UINT16Encoder> UINT16KeyTimesInformation;
  330. typedef CKeyTimesInformation<uint8, ByteEncoder>    ByteKeyTimesInformation;
  331.  
  332. template<class TKeyTime, class TEncoder>
  333. class CKeyTimesInformationStartStop : public IKeyTimesInformation
  334. {
  335. public:
  336.  
  337.         CKeyTimesInformationStartStop() { m_arrKeys[0] = (TKeyTime)0; m_arrKeys[1] = (TKeyTime)0; };
  338.         CKeyTimesInformationStartStop(const TKeyTime* pKeys, uint32 numKeys) { assert(numKeys >= 2); m_arrKeys[0] = pKeys[0]; m_arrKeys[1] = pKeys[1]; };
  339.  
  340.         // return key value in f32 format
  341.         f32 GetKeyValueFloat(uint32 key) const { return /*TEncoder::DecodeKeyValue*/ (float)(m_arrKeys[0] + key); }
  342.  
  343.         // return key number for normalized_time
  344.         uint32 GetKey(f32 normalized_time, f32& difference_time)
  345.         {
  346.                 f32 realtime = normalized_time;
  347.  
  348.                 if (realtime < m_arrKeys[0])
  349.                         return 0;
  350.  
  351.                 if (realtime > m_arrKeys[1])
  352.                         return (uint32)(m_arrKeys[1] - m_arrKeys[0]);
  353.  
  354.                 uint32 nKey = (uint32)realtime;
  355.                 difference_time = realtime - (float)(nKey);
  356.  
  357.                 return nKey;
  358.         }
  359.  
  360.         uint32 GetNumKeys() const { return (uint32)(m_arrKeys[1] - m_arrKeys[0]); }
  361.  
  362.         uint32 AssignKeyTime(const char* pData, uint32 numElements)
  363.         {
  364.                 memcpy(m_arrKeys, pData, sizeof(TKeyTime) * 2);
  365.                 return sizeof(TKeyTime) * 2;
  366.         }
  367.  
  368.         uint32 GetFormat()
  369.         {
  370.                 return TEncoder::GetFormat();
  371.         }
  372.  
  373.         char* GetData()
  374.         {
  375.                 return (char*)(&m_arrKeys[0]);
  376.         }
  377.  
  378.         uint32 GetDataRawSize()
  379.         {
  380.                 return sizeof(TKeyTime) * 2;
  381.         }
  382.  
  383.         IControllerRelocatableChain* GetRelocateChain()
  384.         {
  385.                 return NULL;
  386.         }
  387.  
  388. private:
  389.  
  390.         TKeyTime m_arrKeys[2]; // start pos, stop pos.
  391. };
  392.  
  393. typedef CKeyTimesInformationStartStop<f32, F32StartStopEncoder>       F32SSKeyTimesInformation;
  394. typedef CKeyTimesInformationStartStop<uint16, UINT16StartStopEncoder> UINT16SSKeyTimesInformation;
  395. typedef CKeyTimesInformationStartStop<uint8, ByteStartStopEncoder>    ByteSSKeyTimesInformation;
  396.  
  397. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  398. // TODO: Move these functions to an utility header
  399. #if CRY_PLATFORM_WINDOWS
  400.  
  401.         #include <intrin.h>
  402.         #pragma intrinsic(_BitScanForward)
  403.         #pragma intrinsic(_BitScanReverse)
  404.  
  405. inline uint16 GetFirstLowBit(uint16 word)
  406. {
  407.         unsigned long lword(word);
  408.         unsigned long index;
  409.         if (_BitScanForward(&index, lword))
  410.                 return (uint16)(index);
  411.  
  412.         return 16;
  413. }
  414.  
  415. inline uint16 GetFirstHighBit(uint16 word)
  416. {
  417.         unsigned long lword(word);
  418.         unsigned long index;
  419.         if (_BitScanReverse(&index, lword))
  420.                 return (uint16)(index);
  421.  
  422.         return 16;
  423. }
  424.  
  425. #else   // CRY_PLATFORM_WINDOWS
  426.  
  427. inline uint16 GetFirstLowBitTest(uint16 word)
  428. {
  429.         uint16 c(0);
  430.  
  431.         if (word & 1)
  432.                 return 0;
  433.  
  434.         uint16 b;
  435.         do
  436.         {
  437.                 word = word >> 1;
  438.                 b = word & 1;
  439.                 ++c;
  440.         }
  441.         while (!b && c < 16);
  442.  
  443.         return c;
  444. }
  445.  
  446. inline uint16 GetFirstHighBitTest(uint16 word)
  447. {
  448.  
  449.         uint16 c(0);
  450.  
  451.         if (word & 0x8000)
  452.                 return 15;
  453.  
  454.         uint16 b;
  455.         do
  456.         {
  457.                 word = word << 1;
  458.                 b = word & 0x8000;
  459.                 ++c;
  460.         }
  461.         while (!b && c < 16);
  462.  
  463.         if (c == 16)
  464.                 return c;
  465.         else
  466.                 return 15 - c;
  467. }
  468.  
  469. inline uint16 GetFirstLowBit(uint16 word)
  470. {
  471.  
  472.         uint8 rr = word & 0xFF;
  473.         uint16 res = ControllerHelper::m_byteLowBit[rr];
  474.         if (res == 8)
  475.         {
  476.                 res = (ControllerHelper::m_byteLowBit[(word >> 8) & 0xFF]) + 8;
  477.         }
  478.  
  479.         //if (res != GetFirstLowBitTest(word))
  480.         //      int a = 0;
  481.         return res;
  482. }
  483.  
  484. inline uint16 GetFirstHighBit(uint16 word)
  485. {
  486.         uint16 res = ControllerHelper::m_byteHighBit[(word >> 8) & 0xFF] + 8;
  487.         if (res == 24)
  488.         {
  489.                 res = (ControllerHelper::m_byteHighBit[word & 0xFF]);
  490.         }
  491.         //if (res != GetFirstHighBitTest(word))
  492.         //      int a = 0;
  493.  
  494.         return res;
  495. }
  496.  
  497. #endif   // CRY_PLATFORM_WINDOWS
  498.  
  499. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  500. class CKeyTimesInformationBitSet : public IKeyTimesInformation
  501. {
  502. public:
  503.  
  504.         CKeyTimesInformationBitSet()
  505.                 : m_pKeys(nullptr)
  506.                 , m_numKeys(0)
  507.                 , m_lastTime(-1)
  508.         {
  509.         }
  510.  
  511.         CKeyTimesInformationBitSet(uint16* pKeys, uint32 numKeys)
  512.                 : m_pKeys(pKeys)
  513.                 , m_numKeys((numKeys > 0) ? (numKeys | kKeysConstantMask) : 0)
  514.                 , m_lastTime(-1)
  515.         {
  516.         }
  517.  
  518.         ~CKeyTimesInformationBitSet()
  519.         {
  520.                 if (m_pKeys && !IsConstant())
  521.                         CryModuleFree(m_pKeys);
  522.         }
  523.  
  524.         // return key value in f32 format
  525.         f32 GetKeyValueFloat(uint32 key) const
  526.         {
  527.                 if (key == 0)
  528.                 {
  529.                         // first one
  530.  
  531.                         return (float)GetHeader()->m_Start;
  532.                 }
  533.                 else if (key >= GetNumKeys() - 1)
  534.                 {
  535.                         // last one
  536.                         return (float)GetHeader()->m_End;
  537.                 }
  538.                 // worse situation
  539.                 int keys = GetNumKeys();
  540.                 int count(0);
  541.                 for (int i = 0; i < keys; ++i)
  542.                 {
  543.                         uint16 bits = GetKeyData(i);
  544.  
  545.                         for (int j = 0; i < 16; ++i)
  546.                         {
  547.                                 if ((bits >> j) & 1)
  548.                                 {
  549.                                         ++count;
  550.                                         if ((count - 1) == key)
  551.                                                 return (float)(i * 16 + j);
  552.                                 }
  553.                         }
  554.                 }
  555.  
  556.                 return 0;
  557.         }
  558.  
  559.         // return key number for normalized_time
  560.         uint32 GetKey(f32 normalized_time, f32& difference_time)
  561.         {
  562.                 f32 realtime = normalized_time;
  563.  
  564.                 if (realtime == m_lastTime)
  565.                 {
  566.                         difference_time = m_LastDifferenceTime;
  567.                         return m_lastKey;
  568.                 }
  569.                 m_lastTime = realtime;
  570.                 uint32 numKey = (uint32)GetHeader()->m_Size;  //m_arrKeys.size();
  571.  
  572.                 f32 keytime_start = (float)GetHeader()->m_Start;
  573.                 f32 keytime_end = (float)GetHeader()->m_End;
  574.                 f32 test_end = keytime_end;
  575.  
  576.                 if (realtime < keytime_start)
  577.                         test_end += realtime;
  578.  
  579.                 if (realtime < keytime_start)
  580.                 {
  581.                         difference_time = 0;
  582.                         m_lastKey = 0;
  583.                         return 0;
  584.                 }
  585.  
  586.                 if (realtime >= keytime_end)
  587.                 {
  588.                         difference_time = 0;
  589.                         m_lastKey = numKey;
  590.                         return numKey;
  591.                 }
  592.  
  593.                 f32 internalTime = realtime - keytime_start;
  594.                 uint16 uTime = (uint16)internalTime;
  595.                 uint16 piece = (uTime / sizeof(uint16)) >> 3;
  596.                 uint16 bit = /*15 - */ (uTime % 16);
  597.                 uint16 data = GetKeyData(piece);
  598.  
  599.                 //left
  600.                 uint16 left = data & (0xFFFF >> (15 - bit));
  601.                 uint16 leftPiece(piece);
  602.                 uint16 nearestLeft = 0;
  603.                 uint16 wBit;
  604.                 while ((wBit = GetFirstHighBit(left)) == 16)
  605.                 {
  606.                         --leftPiece;
  607.                         left = GetKeyData(leftPiece);
  608.                 }
  609.                 nearestLeft = leftPiece * 16 + wBit;
  610.  
  611.                 //right
  612.                 uint16 right = ((data >> (bit + 1)) & 0xFFFF) << (bit + 1);
  613.                 uint16 rigthPiece(piece);
  614.                 uint16 nearestRight = 0;
  615.                 while ((wBit = GetFirstLowBit(right)) == 16)
  616.                 {
  617.                         ++rigthPiece;
  618.                         right = GetKeyData(rigthPiece);
  619.                 }
  620.  
  621.                 nearestRight = ((rigthPiece * sizeof(uint16)) << 3) + wBit;
  622.                 m_LastDifferenceTime = difference_time = (f32)(internalTime - (f32)nearestLeft) / ((f32)nearestRight - (f32)nearestLeft);
  623.  
  624.                 // count nPos
  625.                 uint32 nPos(0);
  626.                 for (uint16 i = 0; i < rigthPiece; ++i)
  627.                 {
  628.                         uint16 data2 = GetKeyData(i);
  629.                         nPos += ControllerHelper::m_byteTable[data2 & 255] + ControllerHelper::m_byteTable[data2 >> 8];
  630.                 }
  631.  
  632.                 data = GetKeyData(rigthPiece);
  633.                 data = ((data << (15 - wBit)) & 0xFFFF) >> (15 - wBit);
  634.                 nPos += ControllerHelper::m_byteTable[data & 255] + ControllerHelper::m_byteTable[data >> 8];
  635.  
  636.                 m_lastKey = nPos - 1;
  637.  
  638.                 return m_lastKey;
  639.         }
  640.  
  641.         uint32 GetNumKeys() const { return GetHeader()->m_Size; };
  642.  
  643.         uint32 AssignKeyTime(const char* pData, uint32 numElements)
  644.         {
  645. #ifndef _RELEASE
  646.                 if (IsConstant())
  647.                 {
  648.                         __debugbreak();
  649.                         return 0;
  650.                 }
  651. #endif
  652.  
  653.                 if (m_pKeys)
  654.                         CryModuleFree(m_pKeys);
  655.  
  656.                 uint32 sz = sizeof(uint16) * numElements;
  657.  
  658.                 m_pKeys = (uint16*)CryModuleMalloc(sz);
  659.                 m_numKeys = numElements;
  660.  
  661.                 memcpy(&m_pKeys[0], pData, sz);
  662.  
  663.                 return sz;
  664.         }
  665.  
  666.         uint32 GetFormat()
  667.         {
  668.                 return eBitset;
  669.         }
  670.  
  671.         char* GetData()
  672.         {
  673.                 return (char*)m_pKeys;
  674.         }
  675.  
  676.         uint32 GetDataRawSize()
  677.         {
  678.                 return (m_numKeys & kKeysSizeMask) * sizeof(uint16);
  679.         }
  680.  
  681.         IControllerRelocatableChain* GetRelocateChain()
  682.         {
  683.                 return NULL;
  684.         }
  685.  
  686. private:
  687.  
  688.         CKeyTimesInformationBitSet(const CKeyTimesInformationBitSet&); //= delete;
  689.         void operator=(const CKeyTimesInformationBitSet&);             //= delete;
  690.  
  691.         enum
  692.         {
  693.                 kKeysSizeMask     = 0x7fffffff,
  694.                 kKeysConstantMask = 0x80000000,
  695.         };
  696.  
  697.         struct Header
  698.         {
  699.                 uint16 m_Start;
  700.                 uint16 m_End;
  701.                 uint16 m_Size;
  702.         };
  703.  
  704.         Header* GetHeader() const
  705.         {
  706.                 return (Header*)m_pKeys;
  707.         }
  708.  
  709.         uint16 GetKeyData(int i) const
  710.         {
  711.                 return m_pKeys[3 + i];
  712.         }
  713.  
  714.         bool IsConstant() const
  715.         {
  716.                 return (m_numKeys & kKeysConstantMask) != 0;
  717.         }
  718.  
  719.         uint32 GetNumKeys_Int() const
  720.         {
  721.                 return m_numKeys & kKeysSizeMask;
  722.         }
  723.  
  724.         uint16* m_pKeys;
  725.         uint32  m_numKeys;
  726.  
  727.         f32     m_lastTime;
  728.         f32     m_LastDifferenceTime;
  729.         uint32  m_lastKey;
  730. };
  731.  
  732. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  733. class ITrackPositionStorage : public IControllerRelocatableChain
  734. {
  735. public:
  736.         virtual ~ITrackPositionStorage() {}
  737.         virtual char*  GetData() = 0;
  738.         virtual uint32 AssignData(const char* pData, uint32 numElements) = 0;
  739.         virtual uint32 GetDataRawSize() = 0;
  740.         virtual uint32 GetFormat() = 0;
  741.         virtual void   GetValue(uint32 key, Vec3& val) = 0;
  742.         virtual size_t SizeOfPosController() = 0;
  743. };
  744.  
  745. class ITrackRotationStorage : public IControllerRelocatableChain
  746. {
  747. public:
  748.         virtual ~ITrackRotationStorage() {}
  749.         virtual char*  GetData() = 0;
  750.         virtual uint32 AssignData(const char* pData, uint32 numElements) = 0;
  751.         virtual uint32 GetDataRawSize() = 0;
  752.         virtual uint32 GetFormat() = 0;
  753.         virtual void   GetValue(uint32 key, Quat& val) = 0;
  754.         virtual size_t SizeOfRotController() = 0;
  755. };
  756.  
  757. template<class TData, class TStorage, class TBase>                                              // TODO: TBase and TData can be easily derived from TStorage.
  758. class CTrackDataStorageInt : public TBase
  759. {
  760. public:
  761.  
  762.         CTrackDataStorageInt()
  763.                 : m_numKeys(0)
  764.                 , m_pKeys(nullptr)
  765.         {
  766.         }
  767.  
  768.         CTrackDataStorageInt(TStorage* pData, uint32 numElements)
  769.                 : m_numKeys(numElements | (numElements > 0 ? kKeysConstantMask : 0))
  770.                 , m_pKeys(pData)
  771.         {
  772.         }
  773.  
  774.         ~CTrackDataStorageInt()
  775.         {
  776.                 if (!IsConstant() && m_hHdl.IsValid())
  777.                         g_controllerHeap.Free(m_hHdl);
  778.         }
  779.  
  780.         virtual uint32 AssignData(const char* pData, uint32 numElements)
  781.         {
  782. #ifndef _RELEASE
  783.                 if (IsConstant())
  784.                 {
  785.                         __debugbreak();
  786.                         return 0;
  787.                 }
  788. #endif
  789.  
  790.                 if (m_hHdl.IsValid())
  791.                         g_controllerHeap.Free(m_hHdl);
  792.  
  793.                 uint32 sz = numElements * sizeof(TStorage);
  794.                 this->LinkTo(NULL);
  795.                 CControllerDefragHdl hdl = g_controllerHeap.AllocPinned(sz, this);
  796.                 m_hHdl = hdl;
  797.                 m_pKeys = (TStorage*)g_controllerHeap.WeakPin(hdl);
  798.                 m_numKeys = numElements;
  799.                 memcpy(m_pKeys, pData, sz);
  800.                 g_controllerHeap.Unpin(hdl);
  801.  
  802.                 return sz;
  803.         }
  804.  
  805.         char* GetData()
  806.         {
  807.                 return (char*) m_pKeys;
  808.         }
  809.  
  810.         uint32 GetDataRawSize()
  811.         {
  812.                 return GetNumKeys() * sizeof(TStorage);
  813.         }
  814.  
  815.         void Relocate(char* pDst, char* pSrc)
  816.         {
  817.                 ptrdiff_t offs = reinterpret_cast<char*>(m_pKeys) - pSrc;
  818.                 m_pKeys = reinterpret_cast<TStorage*>(pDst + offs);
  819.         }
  820.  
  821.         void GetValue(uint32 key, TData& val)
  822.         {
  823.                 TStorage l = m_pKeys[key];
  824.                 l.ToExternalType(val);
  825.         }
  826.  
  827.         virtual uint32 GetFormat()
  828.         {
  829.                 return TStorage::GetFormat();
  830.         }
  831.  
  832.         virtual size_t SizeOfRotController()
  833.         {
  834.                 size_t keys = GetNumKeys();
  835.                 size_t s0 = sizeof(*this);
  836.                 size_t s1 = keys * sizeof(TStorage);
  837.                 return s0 + s1;
  838.         }
  839.         virtual size_t SizeOfPosController()
  840.         {
  841.                 size_t keys = GetNumKeys();
  842.                 size_t s0 = sizeof(*this);
  843.                 size_t s1 = keys * sizeof(TStorage);
  844.                 return s0 + s1;
  845.         }
  846.  
  847. private:
  848.  
  849.         CTrackDataStorageInt(const CTrackDataStorageInt<TData, TStorage, TBase>&);   //= delete;
  850.         void operator=(const CTrackDataStorageInt<TData, TStorage, TBase>&);         //= delete;
  851.  
  852.         enum
  853.         {
  854.                 kKeysSizeMask     = 0x7fffffff,
  855.                 kKeysConstantMask = 0x80000000,
  856.         };
  857.  
  858.         ILINE uint32 IsConstant() const { return m_numKeys & kKeysConstantMask; }
  859.         ILINE uint32 GetNumKeys() const { return m_numKeys & kKeysSizeMask; }
  860.  
  861.         TStorage*            m_pKeys;
  862.         uint32               m_numKeys;
  863.         CControllerDefragHdl m_hHdl;
  864. };
  865.  
  866. template<class TData, class TStorage, class TBase>
  867. class CTrackDataStorage : public CTrackDataStorageInt<TData, TStorage, TBase>    // TODO: This class doesn't really introduce any functionality, it should probably be removed.
  868. {
  869. public:
  870.  
  871.         typedef TStorage StorageType;
  872.  
  873.         CTrackDataStorage() {}
  874.  
  875.         CTrackDataStorage(TStorage* pData, uint32 numElements)
  876.                 : CTrackDataStorageInt<TData, TStorage, TBase>(pData, numElements)
  877.         {
  878.         }
  879.  
  880.         virtual void AddRef()  {}
  881.         virtual void Release() { delete this; }
  882. };
  883.  
  884. typedef CTrackDataStorage<Vec3, NoCompressVec3, ITrackPositionStorage>        NoCompressPosition;
  885. typedef NoCompressPosition                                                    NoCompressPositionPtr;
  886.  
  887. typedef CTrackDataStorage<Quat, NoCompressQuat, ITrackRotationStorage>        NoCompressRotation;
  888. typedef NoCompressRotation*                                                   NoCompressRotationPtr;
  889.  
  890. typedef CTrackDataStorage<Quat, SmallTree48BitQuat, ITrackRotationStorage>    SmallTree48BitQuatRotation;
  891. typedef SmallTree48BitQuatRotation*                                           SmallTree48BitQuatRotationPtr;
  892.  
  893. typedef CTrackDataStorage<Quat, SmallTree64BitQuat, ITrackRotationStorage>    SmallTree64BitQuatRotation;
  894. typedef SmallTree64BitQuatRotation*                                           SmallTree64BitQuatRotationPtr;
  895.  
  896. typedef CTrackDataStorage<Quat, SmallTree64BitExtQuat, ITrackRotationStorage> SmallTree64BitExtQuatRotation;
  897. typedef SmallTree64BitExtQuatRotation*                                        SmallTree64BitExtQuatRotationPtr;
  898.  
  899. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  900. class ITrackInformation
  901. {
  902. public:
  903.  
  904.         ITrackInformation()
  905.                 : m_pKeyTimes(nullptr)
  906.         {
  907.         }
  908.  
  909.         virtual ~ITrackInformation() {}
  910.  
  911.         uint32 GetNumKeys()
  912.         {
  913.                 return m_pKeyTimes->GetNumKeys();
  914.         }
  915.  
  916.         f32 GetTimeFromKey(uint32 key)
  917.         {
  918.                 return m_pKeyTimes->GetKeyValueFloat(key);
  919.         }
  920.  
  921.         void SetKeyTimesInformation(_smart_ptr<IKeyTimesInformation>& ptr)
  922.         {
  923.                 m_pKeyTimes = ptr;
  924.         }
  925.  
  926.         _smart_ptr<IKeyTimesInformation>& GetKeyTimesInformation()
  927.         {
  928.                 return m_pKeyTimes;
  929.         }
  930.  
  931.         virtual char* GetData() = 0;
  932.  
  933. protected:
  934.  
  935.         _smart_ptr<IKeyTimesInformation> m_pKeyTimes;
  936. };
  937.  
  938. class IPositionController : public ITrackInformation
  939. {
  940. public:
  941.  
  942.         virtual ~IPositionController()
  943.         {
  944.                 delete m_pData;
  945.         }
  946.  
  947.         IPositionController()
  948.                 : m_pData(nullptr)
  949.         {
  950.         }
  951.  
  952.         virtual void   GetValue(f32 normalized_time, Vec3& quat) = 0;
  953.  
  954.         virtual size_t SizeOfPosController()
  955.         {
  956.                 const uint32 rawSize = m_pKeyTimes->GetDataRawSize();
  957.                 const size_t s0 = sizeof(IPositionController);
  958.                 const size_t s1 = m_pData->SizeOfPosController();
  959.                 return s0 + s1 + rawSize;
  960.         }
  961.  
  962.         virtual void GetValueFromKey(uint32 key, Vec3& val);
  963.  
  964.         virtual void SetPositionStorage(ITrackPositionStorage* ptr)
  965.         {
  966.                 m_pData = ptr;
  967.         }
  968.  
  969.         virtual uint32 GetFormat()
  970.         {
  971.                 return m_pData->GetFormat();
  972.         }
  973.  
  974.         char* GetData()
  975.         {
  976.                 return m_pData->GetData();
  977.         }
  978.  
  979. protected:
  980.  
  981.         ITrackPositionStorage* m_pData;
  982. };
  983.  
  984. class IRotationController : public ITrackInformation
  985. {
  986. public:
  987.  
  988.         IRotationController()
  989.                 : m_pData(nullptr)
  990.         {
  991.         }
  992.  
  993.         virtual ~IRotationController()
  994.         {
  995.                 delete m_pData;
  996.         }
  997.  
  998.         virtual void   GetValue(f32 normalized_time, Quat& quat) = 0;
  999.  
  1000.         virtual size_t SizeOfRotController()
  1001.         {
  1002.                 const uint32 rawSize = m_pKeyTimes->GetDataRawSize();
  1003.                 return sizeof(IRotationController) + m_pData->SizeOfRotController() + rawSize;
  1004.         }
  1005.  
  1006.         virtual void GetValueFromKey(uint32 key, Quat& val);
  1007.  
  1008.         virtual void SetRotationStorage(ITrackRotationStorage*& ptr)
  1009.         {
  1010.                 m_pData = ptr;
  1011.         }
  1012.  
  1013.         virtual uint32 GetFormat()
  1014.         {
  1015.                 return m_pData->GetFormat();
  1016.         }
  1017.  
  1018.         char* GetData()
  1019.         {
  1020.                 return m_pData->GetData();
  1021.         }
  1022.  
  1023. protected:
  1024.  
  1025.         ITrackRotationStorage* m_pData;
  1026. };
  1027.  
  1028. struct Vec3Lerp
  1029. {
  1030.         static inline void Blend(Vec3& res, const Vec3& val1, const Vec3& val2, f32 t)
  1031.         {
  1032.                 res.SetLerp(val1, val2, t);
  1033.         }
  1034. };
  1035.  
  1036. struct QuatLerp
  1037. {
  1038.         static inline void Blend(Quat& res, const Quat& val1, const Quat& val2, f32 t)
  1039.         {
  1040.                 res.SetNlerp(val1, val2, t);
  1041.         }
  1042. };
  1043.  
  1044. template<class TData, class TInterpolator, class TBase>   // TODO: TData and TBase can be easily derived from TInterpolator.
  1045. class CAdvancedTrackInformation : public TBase
  1046. {
  1047. public:
  1048.  
  1049.         virtual ~CAdvancedTrackInformation() {}
  1050.  
  1051.         virtual void GetValue(f32 normalized_time, TData& pos)
  1052.         {
  1053.                 //DEFINE_PROFILER_SECTION("ControllerPQ::GetValue");
  1054.                 f32 t;
  1055.                 uint32 key = this->m_pKeyTimes->GetKey(normalized_time, t);
  1056.  
  1057.                 if (key == 0)
  1058.                 {
  1059.                         CRY_ALIGN(16) TData p1;
  1060.                         TBase::GetValueFromKey(0, p1);
  1061.                         pos = p1;
  1062.                 }
  1063.                 else
  1064.                 {
  1065.                         uint32 numKeys = this->GetNumKeys();
  1066.                         if (key >= numKeys)
  1067.                         {
  1068.                                 CRY_ALIGN(16) TData p1;
  1069.                                 TBase::GetValueFromKey(key - 1, p1);
  1070.                                 pos = p1;
  1071.                         }
  1072.                         else
  1073.                         {
  1074.                                 //TData p1, p2;
  1075.                                 CRY_ALIGN(16) TData p1;
  1076.                                 CRY_ALIGN(16) TData p2;
  1077.                                 TBase::GetValueFromKey(key - 1, p1);
  1078.                                 TBase::GetValueFromKey(key, p2);
  1079.  
  1080.                                 TInterpolator::Blend(pos, p1, p2, t);
  1081.                         }
  1082.                 }
  1083.         }
  1084. };
  1085.  
  1086. typedef CAdvancedTrackInformation<Quat, QuatLerp, IRotationController> RotationTrackInformation;
  1087. typedef CAdvancedTrackInformation<Vec3, Vec3Lerp, IPositionController> PositionTrackInformation;
  1088.  
  1089. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1090. class CController : public IController
  1091. {
  1092. public:
  1093.  
  1094.         CController()
  1095.                 : m_pRotationController(nullptr)
  1096.                 , m_pPositionController(nullptr)
  1097.                 , m_pScaleController(nullptr)
  1098.         {
  1099.         }
  1100.  
  1101.         ~CController()
  1102.         {
  1103.                 delete m_pRotationController;
  1104.                 delete m_pPositionController;
  1105.                 delete m_pScaleController;
  1106.         }
  1107.  
  1108.         //////////////////////////////////////////////////////////////////////////
  1109.         // IController
  1110.         virtual JointState GetOPS(f32 normalized_time, Quat& quat, Vec3& pos, Diag33& scale) const override;
  1111.         virtual JointState GetOP(f32 normalized_time, Quat& quat, Vec3& pos) const override;
  1112.         virtual JointState GetO(f32 normalized_time, Quat& quat) const override;
  1113.         virtual JointState GetP(f32 normalized_time, Vec3& pos) const override;
  1114.         virtual JointState GetS(f32 normalized_time, Diag33& scl) const override;
  1115.         virtual int32      GetO_numKey() const override;
  1116.         virtual int32      GetP_numKey() const override;
  1117.         virtual size_t     GetRotationKeysNum() const override;
  1118.         virtual size_t     GetPositionKeysNum() const override;
  1119.         virtual size_t     GetScaleKeysNum() const override;
  1120.         virtual size_t     SizeOfController() const override;
  1121.         virtual size_t     ApproximateSizeOfThis() const override;
  1122.         //////////////////////////////////////////////////////////////////////////
  1123.  
  1124.         // TODO: Would be nice to introduce some ownership semantics on the Set*Controller methods instead of using a raw pointer (all of these are a raw pointer typedef at the time of writing).
  1125.         void SetRotationController(IRotationController* ptr)
  1126.         {
  1127.                 m_pRotationController = ptr;
  1128.         }
  1129.  
  1130.         void SetPositionController(IPositionController* ptr)
  1131.         {
  1132.                 m_pPositionController = ptr;
  1133.         }
  1134.  
  1135.         void SetScaleController(IPositionController* ptr)
  1136.         {
  1137.                 m_pScaleController = ptr;
  1138.         }
  1139.  
  1140. private:
  1141.         IRotationController* m_pRotationController;
  1142.         IPositionController* m_pPositionController;
  1143.         IPositionController* m_pScaleController;
  1144. };
  1145.  
  1146. TYPEDEF_AUTOPTR(CController);
  1147.  
downloadControllerPQ.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