开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
hkStressTestCinfo.h
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：8k
源码类别：

其他游戏

开发平台：

Visual C++

hkStressTestCinfo.h：源码内容
  1. /* 
  2.  * 
  3.  * Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
  4.  * prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
  5.  * Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
  6.  * 
  7.  */
  8. #ifndef DEMOS_TEST_UNITTEST_HKSERIALIZE_XML_HKSTRESSTESTCINFO_XML_H
  9. #define DEMOS_TEST_UNITTEST_HKSERIALIZE_XML_HKSTRESSTESTCINFO_XML_H
  11. #include <Common/Base/hkBase.h>
  12. #include <Common/Base/hkBase.h>
  14. /// hkStressTestCinfo meta information
  15. extern const class hkClass hkStressTestCinfoClass;
  17. /// A class to test all parts of the serialization infrastructure.
  18. class hkStressTestCinfo
  19. {
  20. public:
  21. HK_DECLARE_REFLECTION();
  22. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_DEMO, hkStressTestCinfo);
  24. ///
  25. enum AnEnum
  26. {
  27. ///
  28. VAL_INVALID,
  29. ///
  30. VAL_TEN=10,
  31. ///
  32. VAL_ELEVEN,
  33. ///
  34. VAL_TWENTY=20
  35. };
  37. ///
  38. struct SimpleStruct
  39. {
  40. HK_DECLARE_REFLECTION();
  41. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_DEMO, SimpleStruct);
  42. ///
  43. hkUint32 m_key;
  45. ///
  46. hkUint32 m_value;
  48. SimpleStruct() : m_key(0), m_value(0) {}
  49. SimpleStruct( const SimpleStruct& s ) : m_key(s.m_key), m_value(s.m_value) {}
  50. };
  52. ///
  53. struct AllPodsStruct
  54. {
  55. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_SERIALIZE, hkStressTestCinfo::AllPodsStruct );
  57. ///
  58. hkBool m_bool;
  60. ///
  61. hkChar m_char;
  63. ///
  64. hkInt8 m_int8;
  66. ///
  67. hkUint8 m_uint8;
  69. ///
  70. hkInt16 m_int16;
  72. ///
  73. hkUint16 m_uint16;
  75. ///
  76. hkInt32 m_int32;
  78. ///
  79. hkUint32 m_uint32;
  81. ///
  82. hkInt64 m_int64;
  84. ///
  85. hkUint64 m_uint64;
  87. ///
  88. hkReal m_real;
  90. ///
  91. hkVector4 m_vector4;
  93. ///
  94. hkQuaternion m_quaternion;
  96. ///
  97. hkMatrix3 m_matrix3;
  99. ///
  100. hkRotation m_rotation;
  102. ///
  103. hkMatrix4 m_matrix4;
  105. ///
  106. hkTransform m_transform;
  107. };
  109. ///
  110. struct StructWithVirtualFunctions
  111. {
  112. HK_DECLARE_REFLECTION();
  113. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_DEMO, StructWithVirtualFunctions);
  115. virtual ~StructWithVirtualFunctions() {}
  116. ///
  117. hkUint32 m_value;
  119. virtual void doesNothingMuch() = 0;
  120. };
  122. ///
  123. struct StructWithVtable : public hkStressTestCinfo::StructWithVirtualFunctions
  124. {
  125. HK_DECLARE_REFLECTION();
  126. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR(HK_MEMORY_CLASS_DEMO, StructWithVtable);
  127. ///
  128. hkUint32 m_newvalue;
  130. virtual void doesNothingMuch() { m_newvalue = 1; }
  132. StructWithVtable() {}
  133. StructWithVtable( const StructWithVtable& s ) : StructWithVirtualFunctions(s), m_newvalue(s.m_newvalue) {}
  135. StructWithVtable( hkFinishLoadedObjectFlag flag ) {}
  136. };
  139. ///
  140. struct StructWithArrays
  141. {
  142. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_SERIALIZE, hkStressTestCinfo::StructWithArrays );
  143. HK_DECLARE_REFLECTION();
  144. ///
  145. hkArray<hkUint32> m_anArray;
  147. ///
  148. hkArray<hkChar*> m_anArrayOfPointers;
  150. ///
  151. hkArray<struct StructWithVtable> m_anArrayOfStructs;
  153. StructWithArrays() {}
  154. StructWithArrays( const StructWithArrays& s ) {}
  156. };
  159. /// Default constructor
  160. hkStressTestCinfo() { }
  162. //
  163. // Members
  164. //
  165. public:
  167. ///
  168. hkBool m_simpleBool;
  170. ///
  171. hkChar m_simpleChar;
  173. ///
  174. hkInt8 m_simpleInt8;
  176. ///
  177. hkUint8 m_simpleUint8;
  179. ///
  180. hkInt16 m_simpleInt16;
  182. ///
  183. hkUint16 m_simpleUint16;
  185. ///
  186. hkInt32 m_simpleInt32;
  188. ///
  189. hkUint32 m_simpleUint32;
  191. ///
  192. hkInt64 m_simpleInt64;
  194. ///
  195. hkUint64 m_simpleUint64;
  197. ///
  198. hkReal m_simpleReal;
  200. ///
  201. hkVector4 m_simpleVector4;
  203. ///
  204. hkQuaternion m_simpleQuaternion;
  206. ///
  207. hkMatrix3 m_simpleMatrix3;
  209. ///
  210. hkRotation m_simpleRotation;
  212. ///
  213. hkMatrix4 m_simpleMatrix4;
  215. ///
  216. hkTransform m_simpleTransform;
  218. ///
  219. void* m_optionalPtr;
  221. ///
  222. hkEnum<AnEnum, hkInt8> m_simpleEnum;
  224. ///
  225. char* m_name;
  227. ///
  228. char* m_metaSyntacticVariable;
  230. ///
  231. struct SimpleStruct m_simpleStruct;
  233. ///
  234. struct SimpleStruct m_simpleStructCarray[6];
  236. ///
  237. hkBool* m_simpleBoolPointer;
  239. ///
  240. hkChar* m_simpleCharPointer;
  242. ///
  243. hkInt8* m_simpleInt8Pointer;
  245. ///
  246. hkUint8* m_simpleUint8Pointer;
  248. ///
  249. hkInt16* m_simpleInt16Pointer;
  251. ///
  252. hkUint16* m_simpleUint16Pointer;
  254. ///
  255. hkInt32* m_simpleInt32Pointer;
  257. ///
  258. hkUint32* m_simpleUint32Pointer;
  260. ///
  261. hkInt64* m_simpleInt64Pointer;
  263. ///
  264. hkUint64* m_simpleUint64Pointer;
  266. ///
  267. hkReal* m_simpleRealPointer;
  269. ///
  270. hkVector4* m_simpleVector4Pointer;
  272. ///
  273. hkQuaternion* m_simpleQuaternionPointer;
  275. ///
  276. hkMatrix3* m_simpleMatrix3Pointer;
  278. ///
  279. hkRotation* m_simpleRotationPointer;
  281. ///
  282. hkMatrix4* m_simpleMatrix4Pointer;
  284. ///
  285. hkTransform* m_simpleTransformPointer;
  287. ///
  288. hkArray<hkChar> m_arrayCharEmpty;
  290. ///
  291. hkArray<hkInt8> m_arrayInt8Empty;
  293. ///
  294. hkArray<hkUint8> m_arrayUint8Empty;
  296. ///
  297. hkArray<hkInt16> m_arrayInt16Empty;
  299. ///
  300. hkArray<hkUint16> m_arrayUint16Empty;
  302. ///
  303. hkArray<hkInt32> m_arrayInt32Empty;
  305. ///
  306. hkArray<hkUint32> m_arrayUint32Empty;
  308. ///
  309. hkArray<hkInt64> m_arrayInt64Empty;
  311. ///
  312. hkArray<hkUint64> m_arrayUint64Empty;
  314. ///
  315. hkArray<hkReal> m_arrayRealEmpty;
  317. ///
  318. hkArray<hkVector4> m_arrayVector4Empty;
  320. ///
  321. hkArray<hkQuaternion> m_arrayQuaternionEmpty;
  323. ///
  324. hkArray<hkMatrix3> m_arrayMatrix3Empty;
  326. ///
  327. hkArray<hkRotation> m_arrayRotationEmpty;
  329. ///
  330. hkArray<hkMatrix4> m_arrayMatrix4Empty;
  332. ///
  333. hkArray<hkTransform> m_arrayTransformEmpty;
  335. ///
  336. hkArray<hkBool> m_arrayBoolEmpty;
  338. ///
  339. hkArray<hkReal> m_arrayRealWithIntializer;
  341. ///
  342. hkArray<hkVector4> m_arrayVector4WithIntializer;
  344. ///
  345. hkBool m_simpleCarrayBoolEmpty[5];
  347. ///
  348. hkChar m_simpleCarrayCharEmpty[5];
  350. ///
  351. hkInt8 m_simpleCarrayInt8Empty[5];
  353. ///
  354. hkUint8 m_simpleCarrayUint8Empty[5];
  356. ///
  357. hkInt16 m_simpleCarrayInt16Empty[5];
  359. ///
  360. hkUint16 m_simpleCarrayUint16Empty[5];
  362. ///
  363. hkInt32 m_simpleCarrayInt32Empty[5];
  365. ///
  366. hkUint32 m_simpleCarrayUint32Empty[5];
  368. ///
  369. hkInt64 m_simpleCarrayInt64Empty[5];
  371. ///
  372. hkUint64 m_simpleCarrayUint64Empty[5];
  374. ///
  375. hkReal m_simpleCarrayRealEmpty[5];
  377. ///
  378. hkVector4 m_simpleCarrayVector4Empty[5];
  380. ///
  381. hkQuaternion m_simpleCarrayQuaternionEmpty[5];
  383. ///
  384. hkMatrix3 m_simpleCarrayMatrix3Empty[5];
  386. ///
  387. hkRotation m_simpleCarrayRotationEmpty[5];
  389. ///
  390. hkMatrix4 m_simpleCarrayMatrix4Empty[5];
  392. ///
  393. hkTransform m_simpleCarrayTransformEmpty[5];
  395. ///
  396. hkReal m_simpleCarrayRealOneInit[5];
  398. ///
  399. hkReal m_simpleCarrayRealFullInit[5];
  401. ///
  402. hkArray<struct SimpleStruct*> m_arrayStructPtrs;
  404. ///
  405. hkArray<struct SimpleStruct> m_arrayStructEmpty;
  407. ///
  408. struct SimpleStruct m_carrayStructEmpty[5];
  410. ///
  411. struct SimpleStruct m_carrayStructInit[5];
  413. ///
  414. hkInt8* m_simpleArray;
  415. hkInt32 m_numSimpleArray;
  417. ///
  418. hkUint16 m_serializeAsZero;
  420. ///
  421. hkUint16* m_serializePointerAsZero;
  423. ///
  424. hkArray<hkUint16> m_serializeArrayAsZero;
  426. ///
  427. //struct StructWithVtable m_structWithVtable;
  429. ///
  430. struct StructWithArrays m_structWithArrays;
  432. ///
  433. //struct StructWithArrays m_cArrayOfStructsWithArrays[5];
  434. };
  436. #endif // DEMOS_TEST_UNITTEST_HKSERIALIZE_XML_HKSTRESSTESTCINFO_XML_H
  438. /*
  439. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  440. * 
  441. * Confidential Information of Havok.  (C) Copyright 1999-2009
  442. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  443. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  444. * rights, and intellectual property rights in the Havok software remain in
  445. * Havok and/or its suppliers.
  446. * 
  447. * Use of this software for evaluation purposes is subject to and indicates
  448. * acceptance of the End User licence Agreement for this product. A copy of
  449. * the license is included with this software and is also available at www.havok.com/tryhavok.
  450. * 
  451. */