Team Fortress 2 Source Code as on 22/4/2020
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

881 lines
27 KiB

  1. //========= Copyright Valve Corporation, All rights reserved. ============//
  2. //
  3. // Purpose:
  4. //
  5. // $NoKeywords: $
  6. //
  7. //=============================================================================//
  8. #include "dt_send.h"
  9. #include "mathlib/mathlib.h"
  10. #include "mathlib/vector.h"
  11. #include "tier0/dbg.h"
  12. #include "dt_utlvector_common.h"
  13. // memdbgon must be the last include file in a .cpp file!!!
  14. #include "tier0/memdbgon.h"
  15. #if !defined(_STATIC_LINKED) || defined(GAME_DLL)
  16. static CNonModifiedPointerProxy *s_pNonModifiedPointerProxyHead = NULL;
  17. void SendProxy_UInt8ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID);
  18. void SendProxy_UInt16ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID);
  19. void SendProxy_UInt32ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID);
  20. #ifdef SUPPORTS_INT64
  21. void SendProxy_UInt64ToInt64( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID);
  22. #endif
  23. const char *s_ElementNames[MAX_ARRAY_ELEMENTS] =
  24. {
  25. "000", "001", "002", "003", "004", "005", "006", "007", "008", "009",
  26. "010", "011", "012", "013", "014", "015", "016", "017", "018", "019",
  27. "020", "021", "022", "023", "024", "025", "026", "027", "028", "029",
  28. "030", "031", "032", "033", "034", "035", "036", "037", "038", "039",
  29. "040", "041", "042", "043", "044", "045", "046", "047", "048", "049",
  30. "050", "051", "052", "053", "054", "055", "056", "057", "058", "059",
  31. "060", "061", "062", "063", "064", "065", "066", "067", "068", "069",
  32. "070", "071", "072", "073", "074", "075", "076", "077", "078", "079",
  33. "080", "081", "082", "083", "084", "085", "086", "087", "088", "089",
  34. "090", "091", "092", "093", "094", "095", "096", "097", "098", "099",
  35. "100", "101", "102", "103", "104", "105", "106", "107", "108", "109",
  36. "110", "111", "112", "113", "114", "115", "116", "117", "118", "119",
  37. "120", "121", "122", "123", "124", "125", "126", "127", "128", "129",
  38. "130", "131", "132", "133", "134", "135", "136", "137", "138", "139",
  39. "140", "141", "142", "143", "144", "145", "146", "147", "148", "149",
  40. "150", "151", "152", "153", "154", "155", "156", "157", "158", "159",
  41. "160", "161", "162", "163", "164", "165", "166", "167", "168", "169",
  42. "170", "171", "172", "173", "174", "175", "176", "177", "178", "179",
  43. "180", "181", "182", "183", "184", "185", "186", "187", "188", "189",
  44. "190", "191", "192", "193", "194", "195", "196", "197", "198", "199",
  45. "200", "201", "202", "203", "204", "205", "206", "207", "208", "209",
  46. "210", "211", "212", "213", "214", "215", "216", "217", "218", "219",
  47. "220", "221", "222", "223", "224", "225", "226", "227", "228", "229",
  48. "230", "231", "232", "233", "234", "235", "236", "237", "238", "239",
  49. "240", "241", "242", "243", "244", "245", "246", "247", "248", "249",
  50. "250", "251", "252", "253", "254", "255", "256", "257", "258", "259",
  51. "260", "261", "262", "263", "264", "265", "266", "267", "268", "269",
  52. "270", "271", "272", "273", "274", "275", "276", "277", "278", "279",
  53. "280", "281", "282", "283", "284", "285", "286", "287", "288", "289",
  54. "290", "291", "292", "293", "294", "295", "296", "297", "298", "299",
  55. "300", "301", "302", "303", "304", "305", "306", "307", "308", "309",
  56. "310", "311", "312", "313", "314", "315", "316", "317", "318", "319",
  57. "320", "321", "322", "323", "324", "325", "326", "327", "328", "329",
  58. "330", "331", "332", "333", "334", "335", "336", "337", "338", "339",
  59. "340", "341", "342", "343", "344", "345", "346", "347", "348", "349",
  60. "350", "351", "352", "353", "354", "355", "356", "357", "358", "359",
  61. "360", "361", "362", "363", "364", "365", "366", "367", "368", "369",
  62. "370", "371", "372", "373", "374", "375", "376", "377", "378", "379",
  63. "380", "381", "382", "383", "384", "385", "386", "387", "388", "389",
  64. "390", "391", "392", "393", "394", "395", "396", "397", "398", "399",
  65. "400", "401", "402", "403", "404", "405", "406", "407", "408", "409",
  66. "410", "411", "412", "413", "414", "415", "416", "417", "418", "419",
  67. "420", "421", "422", "423", "424", "425", "426", "427", "428", "429",
  68. "430", "431", "432", "433", "434", "435", "436", "437", "438", "439",
  69. "440", "441", "442", "443", "444", "445", "446", "447", "448", "449",
  70. "450", "451", "452", "453", "454", "455", "456", "457", "458", "459",
  71. "460", "461", "462", "463", "464", "465", "466", "467", "468", "469",
  72. "470", "471", "472", "473", "474", "475", "476", "477", "478", "479",
  73. "480", "481", "482", "483", "484", "485", "486", "487", "488", "489",
  74. "490", "491", "492", "493", "494", "495", "496", "497", "498", "499",
  75. "500", "501", "502", "503", "504", "505", "506", "507", "508", "509",
  76. "510", "511", "512", "513", "514", "515", "516", "517", "518", "519",
  77. "520", "521", "522", "523", "524", "525", "526", "527", "528", "529",
  78. "530", "531", "532", "533", "534", "535", "536", "537", "538", "539",
  79. "540", "541", "542", "543", "544", "545", "546", "547", "548", "549",
  80. "550", "551", "552", "553", "554", "555", "556", "557", "558", "559",
  81. "560", "561", "562", "563", "564", "565", "566", "567", "568", "569",
  82. "570", "571", "572", "573", "574", "575", "576", "577", "578", "579",
  83. "580", "581", "582", "583", "584", "585", "586", "587", "588", "589",
  84. "590", "591", "592", "593", "594", "595", "596", "597", "598", "599",
  85. "600", "601", "602", "603", "604", "605", "606", "607", "608", "609",
  86. "610", "611", "612", "613", "614", "615", "616", "617", "618", "619",
  87. "620", "621", "622", "623", "624", "625", "626", "627", "628", "629",
  88. "630", "631", "632", "633", "634", "635", "636", "637", "638", "639",
  89. "640", "641", "642", "643", "644", "645", "646", "647", "648", "649",
  90. "650", "651", "652", "653", "654", "655", "656", "657", "658", "659",
  91. "660", "661", "662", "663", "664", "665", "666", "667", "668", "669",
  92. "670", "671", "672", "673", "674", "675", "676", "677", "678", "679",
  93. "680", "681", "682", "683", "684", "685", "686", "687", "688", "689",
  94. "690", "691", "692", "693", "694", "695", "696", "697", "698", "699",
  95. "700", "701", "702", "703", "704", "705", "706", "707", "708", "709",
  96. "710", "711", "712", "713", "714", "715", "716", "717", "718", "719",
  97. "720", "721", "722", "723", "724", "725", "726", "727", "728", "729",
  98. "730", "731", "732", "733", "734", "735", "736", "737", "738", "739",
  99. "740", "741", "742", "743", "744", "745", "746", "747", "748", "749",
  100. "750", "751", "752", "753", "754", "755", "756", "757", "758", "759",
  101. "760", "761", "762", "763", "764", "765", "766", "767", "768", "769",
  102. "770", "771", "772", "773", "774", "775", "776", "777", "778", "779",
  103. "780", "781", "782", "783", "784", "785", "786", "787", "788", "789",
  104. "790", "791", "792", "793", "794", "795", "796", "797", "798", "799",
  105. "800", "801", "802", "803", "804", "805", "806", "807", "808", "809",
  106. "810", "811", "812", "813", "814", "815", "816", "817", "818", "819",
  107. "820", "821", "822", "823", "824", "825", "826", "827", "828", "829",
  108. "830", "831", "832", "833", "834", "835", "836", "837", "838", "839",
  109. "840", "841", "842", "843", "844", "845", "846", "847", "848", "849",
  110. "850", "851", "852", "853", "854", "855", "856", "857", "858", "859",
  111. "860", "861", "862", "863", "864", "865", "866", "867", "868", "869",
  112. "870", "871", "872", "873", "874", "875", "876", "877", "878", "879",
  113. "880", "881", "882", "883", "884", "885", "886", "887", "888", "889",
  114. "890", "891", "892", "893", "894", "895", "896", "897", "898", "899",
  115. "900", "901", "902", "903", "904", "905", "906", "907", "908", "909",
  116. "910", "911", "912", "913", "914", "915", "916", "917", "918", "919",
  117. "920", "921", "922", "923", "924", "925", "926", "927", "928", "929",
  118. "930", "931", "932", "933", "934", "935", "936", "937", "938", "939",
  119. "940", "941", "942", "943", "944", "945", "946", "947", "948", "949",
  120. "950", "951", "952", "953", "954", "955", "956", "957", "958", "959",
  121. "960", "961", "962", "963", "964", "965", "966", "967", "968", "969",
  122. "970", "971", "972", "973", "974", "975", "976", "977", "978", "979",
  123. "980", "981", "982", "983", "984", "985", "986", "987", "988", "989",
  124. "990", "991", "992", "993", "994", "995", "996", "997", "998", "999",
  125. "1000", "1001", "1002", "1003", "1004", "1005", "1006", "1007", "1008", "1009",
  126. "1010", "1011", "1012", "1013", "1014", "1015", "1016", "1017", "1018", "1019",
  127. "1020", "1021", "1022", "1023"
  128. };
  129. CNonModifiedPointerProxy::CNonModifiedPointerProxy( SendTableProxyFn fn )
  130. {
  131. m_pNext = s_pNonModifiedPointerProxyHead;
  132. s_pNonModifiedPointerProxyHead = this;
  133. m_Fn = fn;
  134. }
  135. CStandardSendProxiesV1::CStandardSendProxiesV1()
  136. {
  137. m_Int8ToInt32 = SendProxy_Int8ToInt32;
  138. m_Int16ToInt32 = SendProxy_Int16ToInt32;
  139. m_Int32ToInt32 = SendProxy_Int32ToInt32;
  140. #ifdef SUPPORTS_INT64
  141. m_Int64ToInt64 = SendProxy_Int64ToInt64;
  142. #endif
  143. m_UInt8ToInt32 = SendProxy_UInt8ToInt32;
  144. m_UInt16ToInt32 = SendProxy_UInt16ToInt32;
  145. m_UInt32ToInt32 = SendProxy_UInt32ToInt32;
  146. #ifdef SUPPORTS_INT64
  147. m_UInt64ToInt64 = SendProxy_UInt64ToInt64;
  148. #endif
  149. m_FloatToFloat = SendProxy_FloatToFloat;
  150. m_VectorToVector = SendProxy_VectorToVector;
  151. }
  152. CStandardSendProxies::CStandardSendProxies()
  153. {
  154. m_DataTableToDataTable = SendProxy_DataTableToDataTable;
  155. m_SendLocalDataTable = SendProxy_SendLocalDataTable;
  156. m_ppNonModifiedPointerProxies = &s_pNonModifiedPointerProxyHead;
  157. }
  158. CStandardSendProxies g_StandardSendProxies;
  159. // ---------------------------------------------------------------------- //
  160. // Proxies.
  161. // ---------------------------------------------------------------------- //
  162. void SendProxy_AngleToFloat( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  163. {
  164. float angle;
  165. angle = *((float*)pData);
  166. pOut->m_Float = anglemod( angle );
  167. Assert( IsFinite( pOut->m_Float ) );
  168. }
  169. void SendProxy_FloatToFloat( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  170. {
  171. pOut->m_Float = *((float*)pData);
  172. Assert( IsFinite( pOut->m_Float ) );
  173. }
  174. void SendProxy_QAngles( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
  175. {
  176. QAngle *v = (QAngle*)pData;
  177. pOut->m_Vector[0] = anglemod( v->x );
  178. pOut->m_Vector[1] = anglemod( v->y );
  179. pOut->m_Vector[2] = anglemod( v->z );
  180. }
  181. void SendProxy_VectorToVector( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  182. {
  183. Vector& v = *(Vector*)pData;
  184. Assert( v.IsValid() );
  185. pOut->m_Vector[0] = v[0];
  186. pOut->m_Vector[1] = v[1];
  187. pOut->m_Vector[2] = v[2];
  188. }
  189. void SendProxy_VectorXYToVectorXY( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  190. {
  191. Vector& v = *(Vector*)pData;
  192. Assert( v.IsValid() );
  193. pOut->m_Vector[0] = v[0];
  194. pOut->m_Vector[1] = v[1];
  195. }
  196. #if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!!
  197. void SendProxy_QuaternionToQuaternion( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  198. {
  199. Quaternion& q = *(Quaternion*)pData;
  200. Assert( q.IsValid() );
  201. pOut->m_Vector[0] = q[0];
  202. pOut->m_Vector[1] = q[1];
  203. pOut->m_Vector[2] = q[2];
  204. pOut->m_Vector[3] = q[3];
  205. }
  206. #endif
  207. void SendProxy_Int8ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  208. {
  209. pOut->m_Int = *((const char*)pData);
  210. }
  211. void SendProxy_Int16ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  212. {
  213. pOut->m_Int = *((short*)pData);
  214. }
  215. void SendProxy_Int32ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  216. {
  217. pOut->m_Int = *((int*)pData);
  218. }
  219. #ifdef SUPPORTS_INT64
  220. void SendProxy_Int64ToInt64( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  221. {
  222. pOut->m_Int64 = *((int64*)pData);
  223. }
  224. #endif
  225. void SendProxy_UInt8ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  226. {
  227. pOut->m_Int = *((const unsigned char*)pData);
  228. }
  229. void SendProxy_UInt16ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  230. {
  231. pOut->m_Int = *((unsigned short*)pData);
  232. }
  233. void SendProxy_UInt32ToInt32( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  234. {
  235. *((unsigned long*)&pOut->m_Int) = *((unsigned long*)pData);
  236. }
  237. #ifdef SUPPORTS_INT64
  238. void SendProxy_UInt64ToInt64( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  239. {
  240. *((int64*)&pOut->m_Int64) = *((uint64*)pData);
  241. }
  242. #endif
  243. void SendProxy_StringToString( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  244. {
  245. pOut->m_pString = (const char*)pData;
  246. }
  247. void* SendProxy_DataTableToDataTable( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
  248. {
  249. return (void*)pData;
  250. }
  251. void* SendProxy_DataTablePtrToDataTable( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
  252. {
  253. return *((void**)pData);
  254. }
  255. static void SendProxy_Empty( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID)
  256. {
  257. }
  258. //-----------------------------------------------------------------------------
  259. // Purpose: If the recipient is the same as objectID, go ahead and iterate down
  260. // the m_Local stuff, otherwise, act like it wasn't there at all.
  261. // This way, only the local player receives information about him/herself.
  262. // Input : *pVarData -
  263. // *pOut -
  264. // objectID -
  265. //-----------------------------------------------------------------------------
  266. void* SendProxy_SendLocalDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
  267. {
  268. pRecipients->SetOnly( objectID - 1 );
  269. return ( void * )pVarData;
  270. }
  271. // ---------------------------------------------------------------------- //
  272. // Prop setup functions (for building tables).
  273. // ---------------------------------------------------------------------- //
  274. float AssignRangeMultiplier( int nBits, double range )
  275. {
  276. unsigned long iHighValue;
  277. if ( nBits == 32 )
  278. iHighValue = 0xFFFFFFFE;
  279. else
  280. iHighValue = ((1 << (unsigned long)nBits) - 1);
  281. float fHighLowMul = iHighValue / range;
  282. if ( CloseEnough( range, 0 ) )
  283. fHighLowMul = iHighValue;
  284. // If the precision is messing us up, then adjust it so it won't.
  285. if ( (unsigned long)(fHighLowMul * range) > iHighValue ||
  286. (fHighLowMul * range) > (double)iHighValue )
  287. {
  288. // Squeeze it down smaller and smaller until it's going to produce an integer
  289. // in the valid range when given the highest value.
  290. float multipliers[] = { 0.9999, 0.99, 0.9, 0.8, 0.7 };
  291. int i;
  292. for ( i=0; i < ARRAYSIZE( multipliers ); i++ )
  293. {
  294. fHighLowMul = (float)( iHighValue / range ) * multipliers[i];
  295. if ( (unsigned long)(fHighLowMul * range) > iHighValue ||
  296. (fHighLowMul * range) > (double)iHighValue )
  297. {
  298. }
  299. else
  300. {
  301. break;
  302. }
  303. }
  304. if ( i == ARRAYSIZE( multipliers ) )
  305. {
  306. // Doh! We seem to be unable to represent this range.
  307. Assert( false );
  308. return 0;
  309. }
  310. }
  311. return fHighLowMul;
  312. }
  313. SendProp SendPropFloat(
  314. const char *pVarName,
  315. // Variable name.
  316. int offset, // Offset into container structure.
  317. int sizeofVar,
  318. int nBits, // Number of bits to use when encoding.
  319. int flags,
  320. float fLowValue, // For floating point, low and high values.
  321. float fHighValue, // High value. If HIGH_DEFAULT, it's (1<<nBits).
  322. SendVarProxyFn varProxy
  323. )
  324. {
  325. SendProp ret;
  326. if ( varProxy == SendProxy_FloatToFloat )
  327. {
  328. Assert( sizeofVar == 0 || sizeofVar == 4 );
  329. }
  330. if ( nBits <= 0 || nBits == 32 )
  331. {
  332. flags |= SPROP_NOSCALE;
  333. fLowValue = 0.f;
  334. fHighValue = 0.f;
  335. }
  336. else
  337. {
  338. if(fHighValue == HIGH_DEFAULT)
  339. fHighValue = (1 << nBits);
  340. if (flags & SPROP_ROUNDDOWN)
  341. fHighValue = fHighValue - ((fHighValue - fLowValue) / (1 << nBits));
  342. else if (flags & SPROP_ROUNDUP)
  343. fLowValue = fLowValue + ((fHighValue - fLowValue) / (1 << nBits));
  344. }
  345. ret.m_Type = DPT_Float;
  346. ret.m_pVarName = pVarName;
  347. ret.SetOffset( offset );
  348. ret.m_nBits = nBits;
  349. ret.SetFlags( flags );
  350. ret.m_fLowValue = fLowValue;
  351. ret.m_fHighValue = fHighValue;
  352. ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
  353. ret.SetProxyFn( varProxy );
  354. if( ret.GetFlags() & (SPROP_COORD | SPROP_NOSCALE | SPROP_NORMAL | SPROP_COORD_MP | SPROP_COORD_MP_LOWPRECISION | SPROP_COORD_MP_INTEGRAL ) )
  355. ret.m_nBits = 0;
  356. return ret;
  357. }
  358. SendProp SendPropVector(
  359. const char *pVarName,
  360. int offset,
  361. int sizeofVar,
  362. int nBits, // Number of bits to use when encoding.
  363. int flags,
  364. float fLowValue, // For floating point, low and high values.
  365. float fHighValue, // High value. If HIGH_DEFAULT, it's (1<<nBits).
  366. SendVarProxyFn varProxy
  367. )
  368. {
  369. SendProp ret;
  370. if(varProxy == SendProxy_VectorToVector)
  371. {
  372. Assert(sizeofVar == sizeof(Vector));
  373. }
  374. if ( nBits == 32 )
  375. flags |= SPROP_NOSCALE;
  376. ret.m_Type = DPT_Vector;
  377. ret.m_pVarName = pVarName;
  378. ret.SetOffset( offset );
  379. ret.m_nBits = nBits;
  380. ret.SetFlags( flags );
  381. ret.m_fLowValue = fLowValue;
  382. ret.m_fHighValue = fHighValue;
  383. ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
  384. ret.SetProxyFn( varProxy );
  385. if( ret.GetFlags() & (SPROP_COORD | SPROP_NOSCALE | SPROP_NORMAL | SPROP_COORD_MP | SPROP_COORD_MP_LOWPRECISION | SPROP_COORD_MP_INTEGRAL) )
  386. ret.m_nBits = 0;
  387. return ret;
  388. }
  389. SendProp SendPropVectorXY(
  390. const char *pVarName,
  391. int offset,
  392. int sizeofVar,
  393. int nBits, // Number of bits to use when encoding.
  394. int flags,
  395. float fLowValue, // For floating point, low and high values.
  396. float fHighValue, // High value. If HIGH_DEFAULT, it's (1<<nBits).
  397. SendVarProxyFn varProxy
  398. )
  399. {
  400. SendProp ret;
  401. if(varProxy == SendProxy_VectorXYToVectorXY)
  402. {
  403. Assert(sizeofVar == sizeof(Vector));
  404. }
  405. if ( nBits == 32 )
  406. flags |= SPROP_NOSCALE;
  407. ret.m_Type = DPT_VectorXY;
  408. ret.m_pVarName = pVarName;
  409. ret.SetOffset( offset );
  410. ret.m_nBits = nBits;
  411. ret.SetFlags( flags );
  412. ret.m_fLowValue = fLowValue;
  413. ret.m_fHighValue = fHighValue;
  414. ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
  415. ret.SetProxyFn( varProxy );
  416. if( ret.GetFlags() & (SPROP_COORD | SPROP_NOSCALE | SPROP_NORMAL | SPROP_COORD_MP | SPROP_COORD_MP_LOWPRECISION | SPROP_COORD_MP_INTEGRAL) )
  417. ret.m_nBits = 0;
  418. return ret;
  419. }
  420. #if 0 // We can't ship this since it changes the size of DTVariant to be 20 bytes instead of 16 and that breaks MODs!!!
  421. SendProp SendPropQuaternion(
  422. const char *pVarName,
  423. int offset,
  424. int sizeofVar,
  425. int nBits, // Number of bits to use when encoding.
  426. int flags,
  427. float fLowValue, // For floating point, low and high values.
  428. float fHighValue, // High value. If HIGH_DEFAULT, it's (1<<nBits).
  429. SendVarProxyFn varProxy
  430. )
  431. {
  432. SendProp ret;
  433. if(varProxy == SendProxy_QuaternionToQuaternion)
  434. {
  435. Assert(sizeofVar == sizeof(Quaternion));
  436. }
  437. if ( nBits == 32 )
  438. flags |= SPROP_NOSCALE;
  439. ret.m_Type = DPT_Quaternion;
  440. ret.m_pVarName = pVarName;
  441. ret.SetOffset( offset );
  442. ret.m_nBits = nBits;
  443. ret.SetFlags( flags );
  444. ret.m_fLowValue = fLowValue;
  445. ret.m_fHighValue = fHighValue;
  446. ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
  447. ret.SetProxyFn( varProxy );
  448. if( ret.GetFlags() & (SPROP_COORD | SPROP_NOSCALE | SPROP_NORMAL | SPROP_COORD_MP | SPROP_COORD_MP_LOWPRECISION | SPROP_COORD_MP_INTEGRAL) )
  449. ret.m_nBits = 0;
  450. return ret;
  451. }
  452. #endif
  453. SendProp SendPropAngle(
  454. const char *pVarName,
  455. int offset,
  456. int sizeofVar,
  457. int nBits,
  458. int flags,
  459. SendVarProxyFn varProxy
  460. )
  461. {
  462. SendProp ret;
  463. if(varProxy == SendProxy_AngleToFloat)
  464. {
  465. Assert(sizeofVar == 4);
  466. }
  467. if ( nBits == 32 )
  468. flags |= SPROP_NOSCALE;
  469. ret.m_Type = DPT_Float;
  470. ret.m_pVarName = pVarName;
  471. ret.SetOffset( offset );
  472. ret.m_nBits = nBits;
  473. ret.SetFlags( flags );
  474. ret.m_fLowValue = 0.0f;
  475. ret.m_fHighValue = 360.0f;
  476. ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
  477. ret.SetProxyFn( varProxy );
  478. return ret;
  479. }
  480. SendProp SendPropQAngles(
  481. const char *pVarName,
  482. int offset,
  483. int sizeofVar,
  484. int nBits,
  485. int flags,
  486. SendVarProxyFn varProxy
  487. )
  488. {
  489. SendProp ret;
  490. if(varProxy == SendProxy_AngleToFloat)
  491. {
  492. Assert(sizeofVar == 4);
  493. }
  494. if ( nBits == 32 )
  495. flags |= SPROP_NOSCALE;
  496. ret.m_Type = DPT_Vector;
  497. ret.m_pVarName = pVarName;
  498. ret.SetOffset( offset );
  499. ret.m_nBits = nBits;
  500. ret.SetFlags( flags );
  501. ret.m_fLowValue = 0.0f;
  502. ret.m_fHighValue = 360.0f;
  503. ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
  504. ret.SetProxyFn( varProxy );
  505. return ret;
  506. }
  507. SendProp SendPropInt(
  508. const char *pVarName,
  509. int offset,
  510. int sizeofVar,
  511. int nBits,
  512. int flags,
  513. SendVarProxyFn varProxy
  514. )
  515. {
  516. SendProp ret;
  517. if ( !varProxy )
  518. {
  519. if ( sizeofVar == 1 )
  520. {
  521. varProxy = SendProxy_Int8ToInt32;
  522. }
  523. else if ( sizeofVar == 2 )
  524. {
  525. varProxy = SendProxy_Int16ToInt32;
  526. }
  527. else if ( sizeofVar == 4 )
  528. {
  529. varProxy = SendProxy_Int32ToInt32;
  530. }
  531. #ifdef SUPPORTS_INT64
  532. else if ( sizeofVar == 8 )
  533. {
  534. varProxy = SendProxy_Int64ToInt64;
  535. }
  536. #endif
  537. else
  538. {
  539. Assert(!"SendPropInt var has invalid size");
  540. varProxy = SendProxy_Int8ToInt32; // safest one...
  541. }
  542. }
  543. // Figure out # of bits if the want us to.
  544. if ( nBits <= 0 )
  545. {
  546. Assert( sizeofVar == 1 || sizeofVar == 2 || sizeofVar == 4 );
  547. nBits = sizeofVar * 8;
  548. }
  549. #ifdef SUPPORTS_INT64
  550. ret.m_Type = (sizeofVar == 8) ? DPT_Int64 : DPT_Int;
  551. #else
  552. ret.m_Type = DPT_Int;
  553. #endif
  554. ret.m_pVarName = pVarName;
  555. ret.SetOffset( offset );
  556. ret.m_nBits = nBits;
  557. ret.SetFlags( flags );
  558. // Use UInt proxies if they want unsigned data. This isn't necessary to encode
  559. // the values correctly, but it lets us check the ranges of the data to make sure
  560. // they're valid.
  561. ret.SetProxyFn( varProxy );
  562. if( ret.GetFlags() & SPROP_UNSIGNED )
  563. {
  564. if( varProxy == SendProxy_Int8ToInt32 )
  565. ret.SetProxyFn( SendProxy_UInt8ToInt32 );
  566. else if( varProxy == SendProxy_Int16ToInt32 )
  567. ret.SetProxyFn( SendProxy_UInt16ToInt32 );
  568. else if( varProxy == SendProxy_Int32ToInt32 )
  569. ret.SetProxyFn( SendProxy_UInt32ToInt32 );
  570. #ifdef SUPPORTS_INT64
  571. else if( varProxy == SendProxy_Int64ToInt64 )
  572. ret.SetProxyFn( SendProxy_UInt64ToInt64 );
  573. #endif
  574. }
  575. return ret;
  576. }
  577. SendProp SendPropString(
  578. const char *pVarName,
  579. int offset,
  580. int bufferLen,
  581. int flags,
  582. SendVarProxyFn varProxy)
  583. {
  584. SendProp ret;
  585. Assert( bufferLen <= DT_MAX_STRING_BUFFERSIZE ); // You can only have strings with 8-bits worth of length.
  586. ret.m_Type = DPT_String;
  587. ret.m_pVarName = pVarName;
  588. ret.SetOffset( offset );
  589. ret.SetFlags( flags );
  590. ret.SetProxyFn( varProxy );
  591. return ret;
  592. }
  593. SendProp SendPropArray3(
  594. const char *pVarName,
  595. int offset,
  596. int sizeofVar,
  597. int elements,
  598. SendProp pArrayProp,
  599. SendTableProxyFn varProxy
  600. )
  601. {
  602. SendProp ret;
  603. Assert( elements <= MAX_ARRAY_ELEMENTS );
  604. ret.m_Type = DPT_DataTable;
  605. ret.m_pVarName = pVarName;
  606. ret.SetOffset( offset );
  607. ret.SetDataTableProxyFn( varProxy );
  608. SendProp *pArrayPropAllocated = new SendProp;
  609. *pArrayPropAllocated = pArrayProp;
  610. ret.SetArrayProp( pArrayPropAllocated );
  611. // Handle special proxy types where they always let all clients get the results.
  612. if ( varProxy == SendProxy_DataTableToDataTable || varProxy == SendProxy_DataTablePtrToDataTable )
  613. {
  614. ret.SetFlags( SPROP_PROXY_ALWAYS_YES );
  615. }
  616. SendProp *pProps = new SendProp[elements]; // TODO free that again
  617. for ( int i = 0; i < elements; i++ )
  618. {
  619. pProps[i] = pArrayProp; // copy array element property setting
  620. pProps[i].SetOffset( i*sizeofVar ); // adjust offset
  621. pProps[i].m_pVarName = s_ElementNames[i]; // give unique name
  622. pProps[i].m_pParentArrayPropName = pVarName; // For debugging...
  623. }
  624. SendTable *pTable = new SendTable( pProps, elements, pVarName ); // TODO free that again
  625. ret.SetDataTable( pTable );
  626. return ret;
  627. }
  628. SendProp SendPropDataTable(
  629. const char *pVarName,
  630. int offset,
  631. SendTable *pTable,
  632. SendTableProxyFn varProxy
  633. )
  634. {
  635. SendProp ret;
  636. ret.m_Type = DPT_DataTable;
  637. ret.m_pVarName = pVarName;
  638. ret.SetOffset( offset );
  639. ret.SetDataTable( pTable );
  640. ret.SetDataTableProxyFn( varProxy );
  641. // Handle special proxy types where they always let all clients get the results.
  642. if ( varProxy == SendProxy_DataTableToDataTable || varProxy == SendProxy_DataTablePtrToDataTable )
  643. {
  644. ret.SetFlags( SPROP_PROXY_ALWAYS_YES );
  645. }
  646. if ( varProxy == SendProxy_DataTableToDataTable && offset == 0 )
  647. {
  648. ret.SetFlags( SPROP_COLLAPSIBLE );
  649. }
  650. return ret;
  651. }
  652. SendProp InternalSendPropArray(
  653. const int elementCount,
  654. const int elementStride,
  655. const char *pName,
  656. ArrayLengthSendProxyFn arrayLengthFn
  657. )
  658. {
  659. SendProp ret;
  660. ret.m_Type = DPT_Array;
  661. ret.m_nElements = elementCount;
  662. ret.m_ElementStride = elementStride;
  663. ret.m_pVarName = pName;
  664. ret.SetProxyFn( SendProxy_Empty );
  665. ret.m_pArrayProp = NULL; // This gets set in SendTable_InitTable. It always points at the property that precedes
  666. // this one in the datatable's list.
  667. ret.SetArrayLengthProxy( arrayLengthFn );
  668. return ret;
  669. }
  670. SendProp SendPropExclude(
  671. const char *pDataTableName, // Data table name (given to BEGIN_SEND_TABLE and BEGIN_RECV_TABLE).
  672. const char *pPropName // Name of the property to exclude.
  673. )
  674. {
  675. SendProp ret;
  676. ret.SetFlags( SPROP_EXCLUDE );
  677. ret.m_pExcludeDTName = pDataTableName;
  678. ret.m_pVarName = pPropName;
  679. return ret;
  680. }
  681. // ---------------------------------------------------------------------- //
  682. // SendProp
  683. // ---------------------------------------------------------------------- //
  684. SendProp::SendProp()
  685. {
  686. m_pVarName = NULL;
  687. m_Offset = 0;
  688. m_pDataTable = NULL;
  689. m_ProxyFn = NULL;
  690. m_pExcludeDTName = NULL;
  691. m_pParentArrayPropName = NULL;
  692. m_Type = DPT_Int;
  693. m_Flags = 0;
  694. m_nBits = 0;
  695. m_fLowValue = 0.0f;
  696. m_fHighValue = 0.0f;
  697. m_pArrayProp = 0;
  698. m_ArrayLengthProxy = 0;
  699. m_nElements = 1;
  700. m_ElementStride = -1;
  701. }
  702. SendProp::~SendProp()
  703. {
  704. }
  705. int SendProp::GetNumArrayLengthBits() const
  706. {
  707. Assert( GetType() == DPT_Array );
  708. #if _X360
  709. int elemCount = GetNumElements();
  710. if ( !elemCount )
  711. return 1;
  712. return (32 - _CountLeadingZeros(GetNumElements()));
  713. #else
  714. return Q_log2( GetNumElements() ) + 1;
  715. #endif
  716. }
  717. // ---------------------------------------------------------------------- //
  718. // SendTable
  719. // ---------------------------------------------------------------------- //
  720. SendTable::SendTable()
  721. {
  722. Construct( NULL, 0, NULL );
  723. }
  724. SendTable::SendTable(SendProp *pProps, int nProps, const char *pNetTableName)
  725. {
  726. Construct( pProps, nProps, pNetTableName );
  727. }
  728. SendTable::~SendTable()
  729. {
  730. // Assert( !m_pPrecalc );
  731. }
  732. void SendTable::Construct( SendProp *pProps, int nProps, const char *pNetTableName )
  733. {
  734. m_pProps = pProps;
  735. m_nProps = nProps;
  736. m_pNetTableName = pNetTableName;
  737. m_pPrecalc = 0;
  738. m_bInitialized = false;
  739. m_bHasBeenWritten = false;
  740. m_bHasPropsEncodedAgainstCurrentTickCount = false;
  741. }
  742. #endif