BVB Source Codes

CRYENGINE Show ControllerOpt.h Source code

Return Download CRYENGINE: download ControllerOpt.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. #if !defined(RESOURCE_COMPILER)
  6.         #include <Cry3DEngine/CGF/CGFContent.h>
  7.         #include "QuatQuantization.h"
  8.         #include "ControllerPQ.h"
  9.  
  10. class IControllerOpt : public IController
  11. {
  12. public:
  13.         virtual void        SetRotationKeyTimes(uint32 num, char* pData) = 0;
  14.         virtual void        SetPositionKeyTimes(uint32 num, char* pData) = 0;
  15.         virtual void        SetRotationKeys(uint32 num, char* pData) = 0;
  16.         virtual void        SetPositionKeys(uint32 num, char* pData) = 0;
  17.  
  18.         virtual uint32      GetRotationFormat() const = 0;
  19.         virtual uint32      GetRotationKeyTimesFormat() const = 0;
  20.         virtual uint32      GetPositionFormat() const = 0;
  21.         virtual uint32      GetPositionKeyTimesFormat() const = 0;
  22.  
  23.         virtual const char* GetRotationKeyData() const = 0;
  24.         virtual const char* GetRotationKeyTimesData() const = 0;
  25.         virtual const char* GetPositionKeyData() const = 0;
  26.         virtual const char* GetPositionKeyTimesData() const = 0;
  27.  
  28. };
  29.  
  30. //TYPEDEF_AUTOPTR(IControllerOpt);
  31. typedef IControllerOpt* IControllerOpt_AutoPtr;
  32.  
  33. template<class _PosController, class _RotController>
  34. class CControllerOpt : public IControllerOpt, _PosController, _RotController
  35. {
  36. public:
  37.         //Creation interface
  38.  
  39.         CControllerOpt(){}
  40.  
  41.         ~CControllerOpt(){}
  42.  
  43.         uint32 numKeys() const
  44.         {
  45.                 // now its hack, because num keys might be different
  46.                 return max(this->GetRotationNumCount(), this->GetPositionNumCount());
  47.         }
  48.  
  49.         JointState GetOPS(f32 key, Quat& quat, Vec3& pos, Diag33& scale) const
  50.         {
  51.                 typedef CControllerOpt<_PosController, _RotController> TSelf;
  52.                 return TSelf::GetO(key, quat) | TSelf::GetP(key, pos) | TSelf::GetS(key, scale);
  53.         }
  54.  
  55.         JointState GetOP(f32 key, Quat& quat, Vec3& pos) const
  56.         {
  57.                 typedef CControllerOpt<_PosController, _RotController> TSelf;
  58.                 return TSelf::GetO(key, quat) | TSelf::GetP(key, pos);
  59.         }
  60.  
  61.         JointState GetO(f32 key, Quat& quat) const
  62.         {
  63.                 return this->GetRotationValue(key, quat);
  64.         }
  65.  
  66.         JointState GetP(f32 key, Vec3& pos) const
  67.         {
  68.                 return this->GetPositionValue(key, pos);
  69.         }
  70.  
  71.         JointState GetS(f32 key, Diag33& scale) const
  72.         {
  73.                 return 0;
  74.         }
  75.  
  76.         // returns the start time
  77.         size_t SizeOfController() const
  78.         {
  79.                 size_t res(sizeof(*this));
  80.                 res += this->GetRotationsSize();
  81.                 res += this->GetPositionsSize();
  82.                 return res;
  83.         }
  84.  
  85.         virtual void GetMemoryUsage(ICrySizer* pSizer) const
  86.         {
  87.                 //static_cast<_PosController*>(this)->_PosController::GetMemoryUsage(pSizer);
  88.                 //static_cast<_RotController*>(this)->_RotController::GetMemoryUsage(pSizer);
  89.         }
  90.  
  91.         size_t ApproximateSizeOfThis() const
  92.         {
  93.                 size_t res(sizeof(*this));
  94.                 res += this->GetRotationsSize();
  95.                 res += this->GetPositionsSize();
  96.                 return res;
  97.         }
  98.  
  99.         size_t GetRotationKeysNum() const
  100.         {
  101.                 return this->GetRotationNumCount();
  102.         }
  103.  
  104.         size_t GetPositionKeysNum() const
  105.         {
  106.                 return this->GetPositionNumCount();
  107.         }
  108.  
  109.         void SetRotationKeyTimes(uint32 num, char* pData)
  110.         {
  111.                 this->SetRotKeyTimes/*_RotController::SetKeyTimes*/ (num, pData);
  112.         }
  113.  
  114.         void SetPositionKeyTimes(uint32 num, char* pData)
  115.         {
  116.                 this->SetPosKeyTimes/*_PosController::SetKeyTimes*/ (num, pData);
  117.         }
  118.  
  119.         void SetRotationKeys(uint32 num, char* pData)
  120.         {
  121.                 this->SetRotationData(num, pData);
  122.         }
  123.  
  124.         void SetPositionKeys(uint32 num, char* pData)
  125.         {
  126.                 this->SetPositionData(num, pData);
  127.         }
  128.  
  129.         uint32 GetRotationFormat() const
  130.         {
  131.                 return this->GetRotationType();
  132.         }
  133.  
  134.         uint32 GetRotationKeyTimesFormat() const
  135.         {
  136.                 return this->GetRotationKeyTimeFormat();
  137.         }
  138.  
  139.         uint32 GetPositionFormat() const
  140.         {
  141.                 return this->GetPositionType();
  142.         }
  143.  
  144.         uint32 GetPositionKeyTimesFormat() const
  145.         {
  146.                 return this->GetPositionKeyTimeFormat();
  147.         }
  148.  
  149.         const char* GetRotationKeyData() const
  150.         {
  151.                 return this->GetRotationData();
  152.         }
  153.  
  154.         const char* GetRotationKeyTimesData() const
  155.         {
  156.                 return this->GetRotKeyTimes();
  157.         }
  158.  
  159.         const char* GetPositionKeyData() const
  160.         {
  161.                 return this->GetPositionData();
  162.         }
  163.  
  164.         const char* GetPositionKeyTimesData() const
  165.         {
  166.                 return this->GetPosKeyTimes();
  167.         }
  168.  
  169.         IControllerOpt* CreateController()
  170.         {
  171.                 return (IControllerOpt*)new CControllerOpt<_PosController, _RotController>();
  172.         }
  173.  
  174. };
  175.  
  176. // forward declarations
  177. struct ControllerData;
  178. static uint32 GetKeySelector(f32 normalized_time, f32& difference_time, const ControllerData& rConData);
  179.  
  180. struct ControllerData
  181. {
  182.         ControllerData() {}
  183.  
  184.         ControllerData(int iType, int iKeyType) :
  185.                 m_nDataOffs(0),
  186.                 m_nKeysOffs(0),
  187.                 m_iCount(0),
  188.                 m_eTimeFormat(iKeyType),
  189.                 m_eCompressionType(iType)
  190.         {
  191.         }
  192.  
  193.         void Init(int iType, int iKeyType)
  194.         {
  195.                 m_nDataOffs = 0;
  196.                 m_nKeysOffs = 0;
  197.                 m_iCount = 0;
  198.                 m_eTimeFormat = iKeyType;
  199.                 m_eCompressionType = iType;
  200.         }
  201.  
  202.         // call function to select template implementation of GetKeyData
  203.         uint32 GetKey(f32 normalizedTime, f32& differenceTime) const
  204.         {
  205.                 return GetKeySelector(normalizedTime, differenceTime, *this);
  206.         }
  207.  
  208.         template<typename Type>
  209.         uint32 GetKeyByteData(f32 normalized_time, f32& difference_time, const void* p_data) const
  210.         {
  211.                 const Type* data = reinterpret_cast<const Type*>(p_data);
  212.  
  213.                 f32 realtimef = normalized_time;
  214.                 Type realtime = (Type)realtimef;
  215.  
  216.                 uint32 numKey = GetNumCount();
  217.  
  218.                 Type keytime_start = data[0];
  219.                 Type keytime_end = data[numKey - 1];
  220.  
  221.                 if (realtime < keytime_start)
  222.                 {
  223.                         return 0;
  224.                 }
  225.  
  226.                 if (realtime >= keytime_end)
  227.                 {
  228.                         return numKey;
  229.                 }
  230.  
  231.                 //-------------
  232.                 int nPos = numKey >> 1;
  233.                 int nStep = numKey >> 2;
  234.  
  235.                 // use binary search
  236.                 //TODO: Need check efficiency of []operator. Maybe wise use pointer
  237.                 while (nStep)
  238.                 {
  239.                         if (realtime < data[nPos])
  240.                                 nPos = nPos - nStep;
  241.                         else if (realtime > data[nPos])
  242.                                 nPos = nPos + nStep;
  243.                         else
  244.                                 break;
  245.  
  246.                         nStep = nStep >> 1;
  247.                 }
  248.  
  249.                 // fine-tuning needed since time is not linear
  250.                 while (realtime >= data[nPos])
  251.                         nPos++;
  252.  
  253.                 while (realtime < data[nPos - 1])
  254.                         nPos--;
  255.  
  256.                 // possible error if encoder uses nonlinear methods!!!
  257.                 if (data[nPos] == data[nPos - 1])
  258.                 {
  259.                         difference_time = 0.0f;
  260.                 }
  261.                 else
  262.                 {
  263.                         f32 prevtime = (f32)data[nPos - 1];
  264.                         f32 time = (f32)data[nPos];
  265.                         difference_time = (realtimef - prevtime) / (time - prevtime);
  266.                 }
  267.  
  268.                 assert(difference_time >= 0.0f && difference_time <= 1.0f);
  269.                 return nPos;
  270.         }
  271.  
  272.         uint32 GetKeyBitData(f32 normalized_time, f32& difference_time) const
  273.         {
  274.                 f32 realtime = normalized_time;
  275.  
  276.                 uint32 numKey = (uint32)GetHeader()->m_Size;//m_arrKeys.size();
  277.  
  278.                 f32 keytime_start = (float)GetHeader()->m_Start;
  279.                 f32 keytime_end = (float)GetHeader()->m_End;
  280.                 f32 test_end = keytime_end;
  281.  
  282.                 if (realtime < keytime_start)
  283.                         test_end += realtime;
  284.  
  285.                 if (realtime < keytime_start)
  286.                 {
  287.                         difference_time = 0;
  288.                         return 0;
  289.                 }
  290.  
  291.                 if (realtime >= keytime_end)
  292.                 {
  293.                         difference_time = 0;
  294.                         return numKey;
  295.                 }
  296.  
  297.                 f32 internalTime = realtime - keytime_start;
  298.                 uint16 uTime = (uint16)internalTime;
  299.                 uint16 piece = (uTime / sizeof(uint16)) >> 3;
  300.                 uint16 bit = /*15 - */ (uTime % 16);
  301.                 uint16 data = GetKeyData(piece);
  302.  
  303.                 //left
  304.                 uint16 left = data & (0xFFFF >> (15 - bit));
  305.                 uint16 leftPiece(piece);
  306.                 uint16 nearestLeft = 0;
  307.                 uint16 wBit;
  308.  
  309.                 while ((wBit = GetFirstHighBit(left)) == 16)
  310.                 {
  311.                         --leftPiece;
  312.                         left = GetKeyData(leftPiece);
  313.                 }
  314.                 nearestLeft = leftPiece * 16 + wBit;
  315.  
  316.                 //right
  317.                 uint16 right = ((data >> (bit + 1)) & 0xFFFF) << (bit + 1);
  318.                 uint16 rigthPiece(piece);
  319.                 uint16 nearestRight = 0;
  320.  
  321.                 while ((wBit = GetFirstLowBit(right)) == 16)
  322.                 {
  323.                         ++rigthPiece;
  324.                         right = GetKeyData(rigthPiece);
  325.                 }
  326.  
  327.                 nearestRight = ((rigthPiece * sizeof(uint16)) << 3) + wBit;
  328.                 difference_time = (f32)(internalTime - (f32)nearestLeft) / ((f32)nearestRight - (f32)nearestLeft);
  329.  
  330.                 // count nPos
  331.                 uint32 nPos(0);
  332.                 for (uint16 i = 0; i < rigthPiece; ++i)
  333.                 {
  334.                         uint16 data2 = GetKeyData(i);
  335.                         nPos += ControllerHelper::m_byteTable[data2 & 255] + ControllerHelper::m_byteTable[data2 >> 8];
  336.                 }
  337.  
  338.                 data = GetKeyData(rigthPiece);
  339.                 data = ((data << (15 - wBit)) & 0xFFFF) >> (15 - wBit);
  340.                 nPos += ControllerHelper::m_byteTable[data & 255] + ControllerHelper::m_byteTable[data >> 8];
  341.  
  342.                 return nPos - 1;
  343.         }
  344.  
  345.         // util functions for bitset encoding
  346.         struct Header
  347.         {
  348.                 uint16 m_Start;
  349.                 uint16 m_End;
  350.                 uint16 m_Size;
  351.         };
  352.  
  353.         inline const Header* GetHeader() const
  354.         {
  355.                 return (const Header*)GetData();
  356.         };
  357.  
  358.         ILINE char*       GetData()       { return reinterpret_cast<char*>(this) + m_nDataOffs; }
  359.         ILINE char*       GetKeys()       { return reinterpret_cast<char*>(this) + m_nKeysOffs; }
  360.         ILINE const char* GetData() const { return reinterpret_cast<const char*>(this) + m_nDataOffs; }
  361.         ILINE const char* GetKeys() const { return reinterpret_cast<const char*>(this) + m_nKeysOffs; }
  362.  
  363.         inline uint16     GetKeyData(int i) const
  364.         {
  365.                 const uint16* pData = reinterpret_cast<const uint16*>(GetData());
  366.                 return pData[3 + i];
  367.         };
  368.  
  369.         size_t                  GetKeysNum() const         { return GetNumCount(); }
  370.         size_t                  GetNumCount() const        { return static_cast<size_t>(getTimeFormat() == eBitset ? GetHeader()->m_Size : m_iCount); }
  371.  
  372.         EKeyTimesFormat         getTimeFormat() const      { return static_cast<EKeyTimesFormat>(m_eTimeFormat); }
  373.         ECompressionInformation getCompressionType() const { return static_cast<ECompressionInformation>(m_eCompressionType); }
  374.  
  375.         void                    GetMemoryUsage(ICrySizer* pSizer) const
  376.         {
  377.                 pSizer->AddObject(this, sizeof(*this));
  378.         }
  379.  
  380.         // Data will be within same allocation as controllers, so offsets ought to be less than 2gb away
  381.         int32  m_nDataOffs;
  382.         int32  m_nKeysOffs;
  383.  
  384.         uint16 m_iCount;
  385.  
  386.         // using unsigned chars to store enums to save storage space
  387.         unsigned char m_eTimeFormat;
  388.         unsigned char m_eCompressionType;
  389.  
  390. };
  391.  
  392. // If the size of this structure changes, RC_GetSizeOfControllerOptNonVirtual also needs
  393. // to be updated.
  394.  
  395. class CControllerOptNonVirtual : public IControllerOpt
  396. {
  397. public:
  398.  
  399.         // ============ new interface ===========//
  400. public:
  401.  
  402.         CControllerOptNonVirtual() {};
  403.  
  404.         CControllerOptNonVirtual(int iRotType, int iRotKeyType, int iPosType, int iPosKeyType) :
  405.                 m_position(iPosType, iPosKeyType),
  406.                 m_rotation(iRotType, iRotKeyType)
  407.         {
  408.         }
  409.  
  410.         void Init(int iRotType, int iRotKeyType, int iPosType, int iPosKeyType)
  411.         {
  412.                 m_position.Init(iPosType, iPosKeyType);
  413.                 m_rotation.Init(iRotType, iRotKeyType);
  414.  
  415.         }
  416.  
  417.         // Deliberately nerf'd - instance must be immutable, as it can be moved by defrag
  418.         void AddRef() override   {}
  419.         void Release()  override {}
  420.  
  421.         ~CControllerOptNonVirtual(){}
  422.  
  423.         JointState GetOPS(f32 normalizedTime, Quat& quat, Vec3& pos, Diag33& scale) const override;
  424.         JointState GetOP(f32 normalizedTime, Quat& quat, Vec3& pos) const override;
  425.         JointState GetO(f32 normalizedTime, Quat& quat) const override;
  426.         JointState GetP(f32 normalizedTime, Vec3& pos) const override;
  427.         JointState GetS(f32 normalizedTime, Diag33& pos) const override;
  428.  
  429.         Vec3       GetPosValue(f32 normalizedTime) const
  430.         {
  431.                 //DEFINE_PROFILER_SECTION("ControllerPQ::GetValue");
  432.                 Vec3 pos;
  433.  
  434.                 f32 t;
  435.                 uint32 key = m_position.GetKey(normalizedTime, t);
  436.  
  437.                 IF (key == 0, true)
  438.                 {
  439.                         CryPrefetch(m_position.GetKeys());
  440.                         GetPosValueFromKey(0, pos);
  441.                 }
  442.                 else
  443.                 {
  444.                         IF (key < m_position.GetNumCount(), true)
  445.                         {
  446.                                 // assume that the 48bit(6byte) encodings are used(can be wrong but should be right the most time)
  447.                                 const char* pKeys = m_position.GetKeys();
  448.                                 CryPrefetch(&pKeys[(key - 1) * 6]);
  449.                                 CryPrefetch(&pKeys[key * 6]);
  450.  
  451.                                 CRY_ALIGN(16) Vec3 p1;
  452.                                 CRY_ALIGN(16) Vec3 p2;
  453.  
  454.                                 GetPosValueFromKey(key - 1, p1);
  455.                                 GetPosValueFromKey(key, p2);
  456.  
  457.                                 pos.SetLerp(p1, p2, t);
  458.                         }
  459.                         else
  460.                         {
  461.                                 GetPosValueFromKey(m_position.GetNumCount() - 1, pos);
  462.                         }
  463.                 }
  464.  
  465.                 return pos;
  466.         }
  467.  
  468.         Quat GetRotValue(f32 normalizedTime) const
  469.         {
  470.                 //DEFINE_PROFILER_SECTION("ControllerPQ::GetValue");
  471.                 Quat pos;
  472.  
  473.                 f32 t;
  474.                 uint32 key = m_rotation.GetKey(normalizedTime, t);
  475.  
  476.                 IF (key == 0, true)
  477.                 {
  478.                         CryPrefetch(m_rotation.GetKeys());
  479.  
  480.                         CRY_ALIGN(16) Quat p1;
  481.                         GetRotValueFromKey(0, p1);
  482.                         pos = p1;
  483.                 }
  484.                 else
  485.                 {
  486.                         IF (key < m_rotation.GetNumCount(), true)
  487.                         {
  488.                                 // assume that the 48bit(6byte) encodings are used(can be wrong but should be right the most time)
  489.                                 const char* pKeys = m_rotation.GetKeys();
  490.                                 CryPrefetch(&pKeys[(key - 1) * 6]);
  491.                                 CryPrefetch(&pKeys[key * 6]);
  492.  
  493.                                 //      Quat p1, p2;
  494.                                 CRY_ALIGN(16) Quat p1;
  495.                                 CRY_ALIGN(16) Quat p2;
  496.  
  497.                                 GetRotValueFromKey(key - 1, p1);
  498.                                 GetRotValueFromKey(key, p2);
  499.  
  500.                                 pos.SetNlerp(p1, p2, t);
  501.                         }
  502.                         else
  503.                         {
  504.                                 CRY_ALIGN(16) Quat p1;
  505.                                 assert(key - 1 < m_rotation.GetNumCount());
  506.                                 GetRotValueFromKey(m_rotation.GetNumCount() - 1, p1);
  507.                                 pos = p1;
  508.                         }
  509.                 }
  510.  
  511.                 return pos;
  512.         }
  513.  
  514.         template<typename CompressionType, typename ValueType>
  515.         void load_value(uint32 key, const char* data, ValueType& val) const
  516.         {
  517.                 const CompressionType* p = reinterpret_cast<const CompressionType*>(data);
  518.                 p[key].ToExternalType(val);
  519.         }
  520.  
  521.         void GetRotValueFromKey(uint32 key, Quat& val) const
  522.         {
  523.                 ECompressionInformation format = m_rotation.getCompressionType();
  524.                 const char* pKeys = m_rotation.GetKeys();
  525.  
  526.                 // branches ordered by probability
  527.                 IF (format == eSmallTree48BitQuat, true)
  528.                 {
  529.                         load_value<SmallTree48BitQuat>(key, pKeys, val);
  530.                 }
  531.                 else
  532.                 {
  533.                         IF (format == eSmallTree64BitExtQuat, true)
  534.                         {
  535.                                 load_value<SmallTree64BitExtQuat>(key, pKeys, val);
  536.                         }
  537.                         else
  538.                         {
  539.                                 IF (format == eSmallTree64BitQuat, true)
  540.                                 {
  541.                                         load_value<SmallTree64BitQuat>(key, pKeys, val);
  542.                                 }
  543.                                 else
  544.                                 {
  545.                                         IF (format == eNoCompressQuat, true)
  546.                                         {
  547.                                                 load_value<NoCompressQuat>(key, pKeys, val);
  548.                                         }
  549.                                         else
  550.                                         {
  551.                                                 CryFatalError("Unknown Rotation Compression format %i\n", format);
  552.                                         }
  553.                                 }
  554.                         }
  555.                 }
  556.  
  557.         }
  558.  
  559.         void GetPosValueFromKey(uint32 key, Vec3& val) const
  560.         {
  561.                 // branches ordered by probability
  562.                 IF (m_position.getCompressionType() == eNoCompressVec3, 1)
  563.                 {
  564.                         load_value<NoCompressVec3>(key, m_position.GetKeys(), val);
  565.                 }
  566.                 else
  567.                 {
  568.                         val = ZERO;
  569.                         //CryFatalError("Unknown Position Compression format %i", m_position.getCompressionType());
  570.                 }
  571.         }
  572.  
  573.         void SetRotationKeyTimes(uint32 num, char* pData) override
  574.         {
  575.                 if (eNoFormat == m_rotation.getTimeFormat()) return;
  576.  
  577.                 m_rotation.m_iCount = static_cast<uint16>(num);
  578.                 m_rotation.m_nDataOffs = static_cast<int32>(pData - reinterpret_cast<char*>(&m_rotation));
  579.         }
  580.  
  581.         void SetPositionKeyTimes(uint32 num, char* pData) override
  582.         {
  583.                 if (eNoFormat == m_position.getTimeFormat()) return;
  584.  
  585.                 m_position.m_iCount = static_cast<uint16>(num);
  586.                 m_position.m_nDataOffs = static_cast<int32>(pData - reinterpret_cast<char*>(&m_position));
  587.         }
  588.  
  589.         void SetRotationKeys(uint32 num, char* pData) override
  590.         {
  591.                 if (eNoFormat == m_rotation.getTimeFormat()) return;
  592.  
  593.                 m_rotation.m_nKeysOffs = static_cast<int32>(pData - reinterpret_cast<char*>(&m_rotation));
  594.         }
  595.  
  596.         void SetPositionKeys(uint32 num, char* pData) override
  597.         {
  598.                 if (eNoFormat == m_position.getTimeFormat()) return;
  599.  
  600.                 m_position.m_nKeysOffs = static_cast<int32>(pData - reinterpret_cast<char*>(&m_position));
  601.         }
  602.  
  603.         uint32      GetRotationFormat() const override         { return m_rotation.getCompressionType(); }
  604.         uint32      GetRotationKeyTimesFormat() const override { return m_rotation.getTimeFormat(); }
  605.  
  606.         uint32      GetPositionFormat() const override         { return m_position.getCompressionType(); }
  607.         uint32      GetPositionKeyTimesFormat() const override { return m_position.getTimeFormat(); }
  608.  
  609.         const char* GetRotationKeyData() const override        { return m_rotation.GetKeys(); }
  610.         const char* GetRotationKeyTimesData() const override   { return m_rotation.GetData(); }
  611.  
  612.         const char* GetPositionKeyData() const override        { return m_position.GetKeys(); }
  613.         const char* GetPositionKeyTimesData() const override   { return m_position.GetData(); }
  614.  
  615.         size_t      SizeOfController() const override
  616.         {
  617.                 return sizeof(*this);
  618.         }
  619.         size_t ApproximateSizeOfThis() const override
  620.         {
  621.                 int sizeOfRotKey = ControllerHelper::GetRotationFormatSizeOf(m_rotation.getCompressionType());
  622.                 int sizeOfPosKey = ControllerHelper::GetPositionsFormatSizeOf(m_position.getCompressionType());
  623.  
  624.                 return sizeof(*this) + sizeOfRotKey * m_rotation.GetNumCount() + sizeOfPosKey * m_position.GetNumCount();
  625.         }
  626.  
  627.         virtual size_t GetRotationKeysNum() const override     { return m_rotation.GetNumCount(); }
  628.         virtual size_t GetPositionKeysNum() const override     { return m_position.GetNumCount(); }
  629.         virtual size_t GetScaleKeysNum() const override        { return 0; }
  630.  
  631.         virtual void   GetMemoryUsage(ICrySizer* pSizer) const {}
  632.  
  633. private:
  634.         ControllerData m_rotation;
  635.         ControllerData m_position;
  636.  
  637. };
  638.  
  639. TYPEDEF_AUTOPTR(CControllerOptNonVirtual);
  640.  
  641. static uint32 GetKeySelector(f32 normalized_time, f32& difference_time, const ControllerData& rConData)
  642. {
  643.         const void* data = rConData.GetData();
  644.  
  645.         EKeyTimesFormat format = rConData.getTimeFormat();
  646.  
  647.         // branches ordered by probability
  648.         IF (format == eByte, true)
  649.         {
  650.                 return rConData.GetKeyByteData<uint8>(normalized_time, difference_time, data);
  651.         }
  652.         else
  653.         {
  654.                 IF (format == eUINT16, 1)
  655.                 {
  656.                         return rConData.GetKeyByteData<uint16>(normalized_time, difference_time, data);
  657.                 }
  658.                 else
  659.                 {
  660.                         IF (format == eF32, 1)
  661.                         {
  662.                                 return rConData.GetKeyByteData<f32>(normalized_time, difference_time, data);
  663.                         }
  664.                         else
  665.                         {
  666.                                 return rConData.GetKeyBitData(normalized_time, difference_time);
  667.                         }
  668.                 }
  669.         }
  670. }
  671.  
  672. #else
  673.  
  674. // Essentially, the DBA needs to reserve space for the CControllerOptNonVirtual instances.
  675. // They need to be allocated within the same allocation as the track data, as the
  676. // CControllerOptNonVirtual instances store offsets to the data, and the allocation as a
  677. // whole gets defragged and relocated.
  678.  
  679. // sizeof(CControllerOptNonVirtual) can't be done in RC, because:
  680.  
  681. // a) The struct depends on a bunch of things that will conflict with RC types
  682. // b) The vtable pointer means the size may be wrong.
  683.  
  684. // So we have this. If it's wrong, you'll get warnings when DBAs are streamed.
  685. inline size_t RC_GetSizeOfControllerOptNonVirtual(size_t pointerSize)
  686. {
  687.         size_t icontrollerSize = Align(pointerSize + sizeof(uint32), pointerSize);
  688.         size_t controllerSize = Align(icontrollerSize + sizeof(uint32), pointerSize);
  689.         return Align(controllerSize + sizeof(uint32) * 6, pointerSize);
  690. }
  691.  
  692. #endif // !defined(RESOURCE_COMPILER)
  693.  
downloadControllerOpt.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