samien
/
RakNet


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549
							<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<title>RakNet: RakNet::BitStream Class Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td style="padding-left: 0.5em;">
   <div id="projectname">RakNet
   &#160;<span id="projectnumber">4.0</span>
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.8.2 -->
  <div id="navrow1" class="tabs">
    <ul class="tablist">
      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
      <li><a href="pages.html"><span>Related&#160;Pages</span></a></li>
      <li><a href="modules.html"><span>Modules</span></a></li>
      <li><a href="namespaces.html"><span>Namespaces</span></a></li>
      <li class="current"><a href="annotated.html"><span>Classes</span></a></li>
      <li><a href="files.html"><span>Files</span></a></li>
    </ul>
  </div>
  <div id="navrow2" class="tabs2">
    <ul class="tablist">
      <li><a href="annotated.html"><span>Class&#160;List</span></a></li>
      <li><a href="classes.html"><span>Class&#160;Index</span></a></li>
      <li><a href="hierarchy.html"><span>Class&#160;Hierarchy</span></a></li>
      <li><a href="functions.html"><span>Class&#160;Members</span></a></li>
    </ul>
  </div>
<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="namespaceRakNet.html">RakNet</a></li><li class="navelem"><a class="el" href="classRakNet_1_1BitStream.html">BitStream</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#pub-methods">Public Member Functions</a> &#124;
<a href="#pub-static-methods">Static Public Member Functions</a> &#124;
<a href="classRakNet_1_1BitStream-members.html">List of all members</a>  </div>
  <div class="headertitle">
<div class="title">RakNet::BitStream Class Reference</div>  </div>
</div><!--header-->
<div class="contents">

<p><code>#include &lt;BitStream.h&gt;</code></p>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-methods"></a>
Public Member Functions</h2></td></tr>
<tr class="memitem:a1aeb4088ac7a611c9eebc629df86890c"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1aeb4088ac7a611c9eebc629df86890c"></a>
&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1aeb4088ac7a611c9eebc629df86890c">BitStream</a> ()</td></tr>
<tr class="memdesc:a1aeb4088ac7a611c9eebc629df86890c"><td class="mdescLeft">&#160;</td><td class="mdescRight">Default Constructor. <br/></td></tr>
<tr class="separator:a1aeb4088ac7a611c9eebc629df86890c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a47b1c7ce200c4815bd2a42d454244bb4"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a47b1c7ce200c4815bd2a42d454244bb4">BitStream</a> (const unsigned int initialBytesToAllocate)</td></tr>
<tr class="memdesc:a47b1c7ce200c4815bd2a42d454244bb4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Create the bitstream, with some number of bytes to immediately allocate.  <a href="#a47b1c7ce200c4815bd2a42d454244bb4"></a><br/></td></tr>
<tr class="separator:a47b1c7ce200c4815bd2a42d454244bb4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a04a200eaf5b379cad2e30d5de15a2c9a"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a04a200eaf5b379cad2e30d5de15a2c9a">BitStream</a> (unsigned char *_data, const unsigned int lengthInBytes, bool _copyData)</td></tr>
<tr class="memdesc:a04a200eaf5b379cad2e30d5de15a2c9a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Initialize the <a class="el" href="classRakNet_1_1BitStream.html">BitStream</a>, immediately setting the data it contains to a predefined pointer.  <a href="#a04a200eaf5b379cad2e30d5de15a2c9a"></a><br/></td></tr>
<tr class="separator:a04a200eaf5b379cad2e30d5de15a2c9a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a60690472e9540e6c3f4b69961e19440f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a60690472e9540e6c3f4b69961e19440f"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a60690472e9540e6c3f4b69961e19440f">Reset</a> (void)</td></tr>
<tr class="memdesc:a60690472e9540e6c3f4b69961e19440f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Resets the bitstream for reuse. <br/></td></tr>
<tr class="separator:a60690472e9540e6c3f4b69961e19440f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adf95af1e57ce9a5386ab6a620ffd593b"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:adf95af1e57ce9a5386ab6a620ffd593b"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#adf95af1e57ce9a5386ab6a620ffd593b">Serialize</a> (bool writeToBitstream, templateType &amp;inOutTemplateVar)</td></tr>
<tr class="memdesc:adf95af1e57ce9a5386ab6a620ffd593b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize any integral type to/from a bitstream.  <a href="#adf95af1e57ce9a5386ab6a620ffd593b"></a><br/></td></tr>
<tr class="separator:adf95af1e57ce9a5386ab6a620ffd593b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6aab79184deb91907b7bc8934ca45bc2"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a6aab79184deb91907b7bc8934ca45bc2"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a6aab79184deb91907b7bc8934ca45bc2">SerializeDelta</a> (bool writeToBitstream, templateType &amp;inOutCurrentValue, const templateType &amp;lastValue)</td></tr>
<tr class="memdesc:a6aab79184deb91907b7bc8934ca45bc2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize any integral type to/from a bitstream.  <a href="#a6aab79184deb91907b7bc8934ca45bc2"></a><br/></td></tr>
<tr class="separator:a6aab79184deb91907b7bc8934ca45bc2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab1cc6838ab5b4477ac7a4021bb1356c3"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ab1cc6838ab5b4477ac7a4021bb1356c3"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ab1cc6838ab5b4477ac7a4021bb1356c3">SerializeDelta</a> (bool writeToBitstream, templateType &amp;inOutCurrentValue)</td></tr>
<tr class="memdesc:ab1cc6838ab5b4477ac7a4021bb1356c3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional version of SerializeDelta when you don't know what the last value is, or there is no last value.  <a href="#ab1cc6838ab5b4477ac7a4021bb1356c3"></a><br/></td></tr>
<tr class="separator:ab1cc6838ab5b4477ac7a4021bb1356c3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5fdf11345fb4e998d411b87426648a36"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a5fdf11345fb4e998d411b87426648a36"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a5fdf11345fb4e998d411b87426648a36">SerializeCompressed</a> (bool writeToBitstream, templateType &amp;inOutTemplateVar)</td></tr>
<tr class="memdesc:a5fdf11345fb4e998d411b87426648a36"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize any integral type to/from a bitstream.  <a href="#a5fdf11345fb4e998d411b87426648a36"></a><br/></td></tr>
<tr class="separator:a5fdf11345fb4e998d411b87426648a36"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8a1991ab41173693f8e9c0e78c9ad2a3"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a8a1991ab41173693f8e9c0e78c9ad2a3"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8a1991ab41173693f8e9c0e78c9ad2a3">SerializeCompressedDelta</a> (bool writeToBitstream, templateType &amp;inOutCurrentValue, const templateType &amp;lastValue)</td></tr>
<tr class="memdesc:a8a1991ab41173693f8e9c0e78c9ad2a3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize any integral type to/from a bitstream.  <a href="#a8a1991ab41173693f8e9c0e78c9ad2a3"></a><br/></td></tr>
<tr class="separator:a8a1991ab41173693f8e9c0e78c9ad2a3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad1ca9bf6bb61905e43003097d7af79fe"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ad1ca9bf6bb61905e43003097d7af79fe"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad1ca9bf6bb61905e43003097d7af79fe">SerializeCompressedDelta</a> (bool writeToBitstream, templateType &amp;inOutTemplateVar)</td></tr>
<tr class="memdesc:ad1ca9bf6bb61905e43003097d7af79fe"><td class="mdescLeft">&#160;</td><td class="mdescRight">Save as SerializeCompressedDelta(templateType &amp;currentValue, const templateType &amp;lastValue) when we have an unknown second parameter.  <a href="#ad1ca9bf6bb61905e43003097d7af79fe"></a><br/></td></tr>
<tr class="separator:ad1ca9bf6bb61905e43003097d7af79fe"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad2e3ec310191a69b9bba227a72e65537"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad2e3ec310191a69b9bba227a72e65537">Serialize</a> (bool writeToBitstream, char *inOutByteArray, const unsigned int numberOfBytes)</td></tr>
<tr class="memdesc:ad2e3ec310191a69b9bba227a72e65537"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize an array or casted stream or raw data. This does NOT do endian swapping.  <a href="#ad2e3ec310191a69b9bba227a72e65537"></a><br/></td></tr>
<tr class="separator:ad2e3ec310191a69b9bba227a72e65537"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1aebab1c543acd21742f380c95255365"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1aebab1c543acd21742f380c95255365">SerializeFloat16</a> (bool writeToBitstream, float &amp;inOutFloat, float floatMin, float floatMax)</td></tr>
<tr class="memdesc:a1aebab1c543acd21742f380c95255365"><td class="mdescLeft">&#160;</td><td class="mdescRight">Serialize a float into 2 bytes, spanning the range between <em>floatMin</em> and <em>floatMax</em>.  <a href="#a1aebab1c543acd21742f380c95255365"></a><br/></td></tr>
<tr class="separator:a1aebab1c543acd21742f380c95255365"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3615fc88c34f910085e0f94a6231926b"><td class="memTemplParams" colspan="2">template&lt;class serializationType , class sourceType &gt; </td></tr>
<tr class="memitem:a3615fc88c34f910085e0f94a6231926b"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a3615fc88c34f910085e0f94a6231926b">SerializeCasted</a> (bool writeToBitstream, sourceType &amp;value)</td></tr>
<tr class="separator:a3615fc88c34f910085e0f94a6231926b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9cfb0266bf435e0bba8b221f089a4aec"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a9cfb0266bf435e0bba8b221f089a4aec"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a9cfb0266bf435e0bba8b221f089a4aec">SerializeBitsFromIntegerRange</a> (bool writeToBitstream, templateType &amp;value, const templateType minimum, const templateType maximum, bool allowOutsideRange=false)</td></tr>
<tr class="separator:a9cfb0266bf435e0bba8b221f089a4aec"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a91e811bf0d8447faedc96261920944cd"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a91e811bf0d8447faedc96261920944cd"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a91e811bf0d8447faedc96261920944cd">SerializeBitsFromIntegerRange</a> (bool writeToBitstream, templateType &amp;value, const templateType minimum, const templateType maximum, const int requiredBits, bool allowOutsideRange=false)</td></tr>
<tr class="separator:a91e811bf0d8447faedc96261920944cd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1e357618f04ee5166fe74a9738a28b82"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a1e357618f04ee5166fe74a9738a28b82"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1e357618f04ee5166fe74a9738a28b82">SerializeNormVector</a> (bool writeToBitstream, templateType &amp;x, templateType &amp;y, templateType &amp;z)</td></tr>
<tr class="memdesc:a1e357618f04ee5166fe74a9738a28b82"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes.  <a href="#a1e357618f04ee5166fe74a9738a28b82"></a><br/></td></tr>
<tr class="separator:a1e357618f04ee5166fe74a9738a28b82"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad39a138bf295277ed6f804d6d2d5d9fb"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ad39a138bf295277ed6f804d6d2d5d9fb"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad39a138bf295277ed6f804d6d2d5d9fb">SerializeVector</a> (bool writeToBitstream, templateType &amp;x, templateType &amp;y, templateType &amp;z)</td></tr>
<tr class="memdesc:ad39a138bf295277ed6f804d6d2d5d9fb"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize a vector, using 10 bytes instead of 12.  <a href="#ad39a138bf295277ed6f804d6d2d5d9fb"></a><br/></td></tr>
<tr class="separator:ad39a138bf295277ed6f804d6d2d5d9fb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a03953490ce2c0fbc5cebb67fdebdb75d"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a03953490ce2c0fbc5cebb67fdebdb75d"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a03953490ce2c0fbc5cebb67fdebdb75d">SerializeNormQuat</a> (bool writeToBitstream, templateType &amp;w, templateType &amp;x, templateType &amp;y, templateType &amp;z)</td></tr>
<tr class="memdesc:a03953490ce2c0fbc5cebb67fdebdb75d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy.  <a href="#a03953490ce2c0fbc5cebb67fdebdb75d"></a><br/></td></tr>
<tr class="separator:a03953490ce2c0fbc5cebb67fdebdb75d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad45063562f20be6154c17bef523ac846"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ad45063562f20be6154c17bef523ac846"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad45063562f20be6154c17bef523ac846">SerializeOrthMatrix</a> (bool writeToBitstream, templateType &amp;m00, templateType &amp;m01, templateType &amp;m02, templateType &amp;m10, templateType &amp;m11, templateType &amp;m12, templateType &amp;m20, templateType &amp;m21, templateType &amp;m22)</td></tr>
<tr class="memdesc:ad45063562f20be6154c17bef523ac846"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each.  <a href="#ad45063562f20be6154c17bef523ac846"></a><br/></td></tr>
<tr class="separator:ad45063562f20be6154c17bef523ac846"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a25c0f31d16b211a2aa7cdb3ec594cbf9"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a25c0f31d16b211a2aa7cdb3ec594cbf9">SerializeBits</a> (bool writeToBitstream, unsigned char *inOutByteArray, const BitSize_t numberOfBitsToSerialize, const bool rightAlignedBits=true)</td></tr>
<tr class="memdesc:a25c0f31d16b211a2aa7cdb3ec594cbf9"><td class="mdescLeft">&#160;</td><td class="mdescRight">Bidirectional serialize/deserialize numberToSerialize bits to/from the input.  <a href="#a25c0f31d16b211a2aa7cdb3ec594cbf9"></a><br/></td></tr>
<tr class="separator:a25c0f31d16b211a2aa7cdb3ec594cbf9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acc0d0bb96142a302385613d44e66558b"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:acc0d0bb96142a302385613d44e66558b"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#acc0d0bb96142a302385613d44e66558b">Write</a> (const templateType &amp;inTemplateVar)</td></tr>
<tr class="memdesc:acc0d0bb96142a302385613d44e66558b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write any integral type to a bitstream.  <a href="#acc0d0bb96142a302385613d44e66558b"></a><br/></td></tr>
<tr class="separator:acc0d0bb96142a302385613d44e66558b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2aa6ce96e75cf8339c29d7101a5bdb3a"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a2aa6ce96e75cf8339c29d7101a5bdb3a"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a2aa6ce96e75cf8339c29d7101a5bdb3a">WritePtr</a> (templateType *inTemplateVar)</td></tr>
<tr class="memdesc:a2aa6ce96e75cf8339c29d7101a5bdb3a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write the dereferenced pointer to any integral type to a bitstream.  <a href="#a2aa6ce96e75cf8339c29d7101a5bdb3a"></a><br/></td></tr>
<tr class="separator:a2aa6ce96e75cf8339c29d7101a5bdb3a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abd8613fe1f3d998a125fd2962c905e67"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:abd8613fe1f3d998a125fd2962c905e67"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#abd8613fe1f3d998a125fd2962c905e67">WriteDelta</a> (const templateType &amp;currentValue, const templateType &amp;lastValue)</td></tr>
<tr class="memdesc:abd8613fe1f3d998a125fd2962c905e67"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write any integral type to a bitstream.  <a href="#abd8613fe1f3d998a125fd2962c905e67"></a><br/></td></tr>
<tr class="separator:abd8613fe1f3d998a125fd2962c905e67"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a09461811793e5719e574d47bc513ac8a"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a09461811793e5719e574d47bc513ac8a"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a09461811793e5719e574d47bc513ac8a">WriteDelta</a> (const templateType &amp;currentValue)</td></tr>
<tr class="memdesc:a09461811793e5719e574d47bc513ac8a"><td class="mdescLeft">&#160;</td><td class="mdescRight">WriteDelta when you don't know what the last value is, or there is no last value.  <a href="#a09461811793e5719e574d47bc513ac8a"></a><br/></td></tr>
<tr class="separator:a09461811793e5719e574d47bc513ac8a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac32700a1c6f26d15890470dba1532ef4"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ac32700a1c6f26d15890470dba1532ef4"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ac32700a1c6f26d15890470dba1532ef4">WriteCompressed</a> (const templateType &amp;inTemplateVar)</td></tr>
<tr class="memdesc:ac32700a1c6f26d15890470dba1532ef4"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write any integral type to a bitstream.  <a href="#ac32700a1c6f26d15890470dba1532ef4"></a><br/></td></tr>
<tr class="separator:ac32700a1c6f26d15890470dba1532ef4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1f8aab299cf0eb021802ed8671844948"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a1f8aab299cf0eb021802ed8671844948"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1f8aab299cf0eb021802ed8671844948">WriteCompressedDelta</a> (const templateType &amp;currentValue, const templateType &amp;lastValue)</td></tr>
<tr class="memdesc:a1f8aab299cf0eb021802ed8671844948"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write any integral type to a bitstream.  <a href="#a1f8aab299cf0eb021802ed8671844948"></a><br/></td></tr>
<tr class="separator:a1f8aab299cf0eb021802ed8671844948"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3a5b260229e8b942a7909935d3a34340"><td class="memTemplParams" colspan="2"><a class="anchor" id="a3a5b260229e8b942a7909935d3a34340"></a>
template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a3a5b260229e8b942a7909935d3a34340"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a3a5b260229e8b942a7909935d3a34340">WriteCompressedDelta</a> (const templateType &amp;currentValue)</td></tr>
<tr class="memdesc:a3a5b260229e8b942a7909935d3a34340"><td class="mdescLeft">&#160;</td><td class="mdescRight">Save as <a class="el" href="classRakNet_1_1BitStream.html#a1f8aab299cf0eb021802ed8671844948" title="Write any integral type to a bitstream.">WriteCompressedDelta(const templateType &amp;currentValue, const templateType &amp;lastValue)</a> when we have an unknown second parameter. <br/></td></tr>
<tr class="separator:a3a5b260229e8b942a7909935d3a34340"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a865bd246780b10e2b9d7c1bc13044343"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a865bd246780b10e2b9d7c1bc13044343"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a865bd246780b10e2b9d7c1bc13044343">Read</a> (templateType &amp;outTemplateVar)</td></tr>
<tr class="memdesc:a865bd246780b10e2b9d7c1bc13044343"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read any integral type from a bitstream.  <a href="#a865bd246780b10e2b9d7c1bc13044343"></a><br/></td></tr>
<tr class="separator:a865bd246780b10e2b9d7c1bc13044343"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad19904647a86e54757a4a740d1275b00"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ad19904647a86e54757a4a740d1275b00"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad19904647a86e54757a4a740d1275b00">ReadDelta</a> (templateType &amp;outTemplateVar)</td></tr>
<tr class="memdesc:ad19904647a86e54757a4a740d1275b00"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read any integral type from a bitstream.  <a href="#ad19904647a86e54757a4a740d1275b00"></a><br/></td></tr>
<tr class="separator:ad19904647a86e54757a4a740d1275b00"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acc394f439d9112328f92e7b22d116e5a"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:acc394f439d9112328f92e7b22d116e5a"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#acc394f439d9112328f92e7b22d116e5a">ReadCompressed</a> (templateType &amp;outTemplateVar)</td></tr>
<tr class="memdesc:acc394f439d9112328f92e7b22d116e5a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read any integral type from a bitstream.  <a href="#acc394f439d9112328f92e7b22d116e5a"></a><br/></td></tr>
<tr class="separator:acc394f439d9112328f92e7b22d116e5a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a099c2c8fb1b5321aacb5bded88a8f300"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a099c2c8fb1b5321aacb5bded88a8f300"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a099c2c8fb1b5321aacb5bded88a8f300">ReadCompressedDelta</a> (templateType &amp;outTemplateVar)</td></tr>
<tr class="memdesc:a099c2c8fb1b5321aacb5bded88a8f300"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read any integral type from a bitstream.  <a href="#a099c2c8fb1b5321aacb5bded88a8f300"></a><br/></td></tr>
<tr class="separator:a099c2c8fb1b5321aacb5bded88a8f300"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a025f73d57a5ebe8fb6393eca5f3616df"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a025f73d57a5ebe8fb6393eca5f3616df">Read</a> (<a class="el" href="classRakNet_1_1BitStream.html">BitStream</a> *bitStream, BitSize_t numberOfBits)</td></tr>
<tr class="memdesc:a025f73d57a5ebe8fb6393eca5f3616df"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read one bitstream to another.  <a href="#a025f73d57a5ebe8fb6393eca5f3616df"></a><br/></td></tr>
<tr class="separator:a025f73d57a5ebe8fb6393eca5f3616df"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0c6e2624a5960f9ac40d4072a6e607e5"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a0c6e2624a5960f9ac40d4072a6e607e5">Write</a> (const char *inputByteArray, const unsigned int numberOfBytes)</td></tr>
<tr class="memdesc:a0c6e2624a5960f9ac40d4072a6e607e5"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write an array or casted stream or raw data. This does NOT do endian swapping.  <a href="#a0c6e2624a5960f9ac40d4072a6e607e5"></a><br/></td></tr>
<tr class="separator:a0c6e2624a5960f9ac40d4072a6e607e5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a26624b5669df1c38f6dd6dabf4c1b769"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a26624b5669df1c38f6dd6dabf4c1b769">Write</a> (<a class="el" href="classRakNet_1_1BitStream.html">BitStream</a> *bitStream, BitSize_t numberOfBits)</td></tr>
<tr class="memdesc:a26624b5669df1c38f6dd6dabf4c1b769"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write one bitstream to another.  <a href="#a26624b5669df1c38f6dd6dabf4c1b769"></a><br/></td></tr>
<tr class="separator:a26624b5669df1c38f6dd6dabf4c1b769"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8b37ff9ba34ce6f98c8521710ba51366"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8b37ff9ba34ce6f98c8521710ba51366">WriteFloat16</a> (float x, float floatMin, float floatMax)</td></tr>
<tr class="memdesc:a8b37ff9ba34ce6f98c8521710ba51366"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a float into 2 bytes, spanning the range between <em>floatMin</em> and <em>floatMax</em>.  <a href="#a8b37ff9ba34ce6f98c8521710ba51366"></a><br/></td></tr>
<tr class="separator:a8b37ff9ba34ce6f98c8521710ba51366"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a13ecfa7830db77b09a1d121bffdccb67"><td class="memTemplParams" colspan="2">template&lt;class serializationType , class sourceType &gt; </td></tr>
<tr class="memitem:a13ecfa7830db77b09a1d121bffdccb67"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a13ecfa7830db77b09a1d121bffdccb67">WriteCasted</a> (const sourceType &amp;value)</td></tr>
<tr class="separator:a13ecfa7830db77b09a1d121bffdccb67"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7e9345107dfe25bfe800aa17826a77b4"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a7e9345107dfe25bfe800aa17826a77b4"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a7e9345107dfe25bfe800aa17826a77b4">WriteBitsFromIntegerRange</a> (const templateType value, const templateType minimum, const templateType maximum, bool allowOutsideRange=false)</td></tr>
<tr class="separator:a7e9345107dfe25bfe800aa17826a77b4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4f0064de4e5e34478bdf43623c8d41a1"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a4f0064de4e5e34478bdf43623c8d41a1"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a4f0064de4e5e34478bdf43623c8d41a1">WriteBitsFromIntegerRange</a> (const templateType value, const templateType minimum, const templateType maximum, const int requiredBits, bool allowOutsideRange=false)</td></tr>
<tr class="separator:a4f0064de4e5e34478bdf43623c8d41a1"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aac37adc6bd171459103131d788fdebf7"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:aac37adc6bd171459103131d788fdebf7"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aac37adc6bd171459103131d788fdebf7">WriteNormVector</a> (templateType x, templateType y, templateType z)</td></tr>
<tr class="memdesc:aac37adc6bd171459103131d788fdebf7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes.  <a href="#aac37adc6bd171459103131d788fdebf7"></a><br/></td></tr>
<tr class="separator:aac37adc6bd171459103131d788fdebf7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0ffa67542bbe1e407a565652becb408f"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a0ffa67542bbe1e407a565652becb408f"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a0ffa67542bbe1e407a565652becb408f">WriteVector</a> (templateType x, templateType y, templateType z)</td></tr>
<tr class="memdesc:a0ffa67542bbe1e407a565652becb408f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a vector, using 10 bytes instead of 12.  <a href="#a0ffa67542bbe1e407a565652becb408f"></a><br/></td></tr>
<tr class="separator:a0ffa67542bbe1e407a565652becb408f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:acb96f0dce8b1a864799d02211cf34d8b"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:acb96f0dce8b1a864799d02211cf34d8b"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#acb96f0dce8b1a864799d02211cf34d8b">WriteNormQuat</a> (templateType w, templateType x, templateType y, templateType z)</td></tr>
<tr class="memdesc:acb96f0dce8b1a864799d02211cf34d8b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy.  <a href="#acb96f0dce8b1a864799d02211cf34d8b"></a><br/></td></tr>
<tr class="separator:acb96f0dce8b1a864799d02211cf34d8b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:adb06e701aa336f41c314b88ae27c60bc"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:adb06e701aa336f41c314b88ae27c60bc"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#adb06e701aa336f41c314b88ae27c60bc">WriteOrthMatrix</a> (templateType m00, templateType m01, templateType m02, templateType m10, templateType m11, templateType m12, templateType m20, templateType m21, templateType m22)</td></tr>
<tr class="memdesc:adb06e701aa336f41c314b88ae27c60bc"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each.  <a href="#adb06e701aa336f41c314b88ae27c60bc"></a><br/></td></tr>
<tr class="separator:adb06e701aa336f41c314b88ae27c60bc"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a25b53ddc6f6bc9a1e0c01cb677a3c6d1"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a25b53ddc6f6bc9a1e0c01cb677a3c6d1">Read</a> (char *output, const unsigned int numberOfBytes)</td></tr>
<tr class="memdesc:a25b53ddc6f6bc9a1e0c01cb677a3c6d1"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read an array or casted stream of byte.  <a href="#a25b53ddc6f6bc9a1e0c01cb677a3c6d1"></a><br/></td></tr>
<tr class="separator:a25b53ddc6f6bc9a1e0c01cb677a3c6d1"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:af8275d390e2114d55449bb4ae2d01d62"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#af8275d390e2114d55449bb4ae2d01d62">ReadFloat16</a> (float &amp;outFloat, float floatMin, float floatMax)</td></tr>
<tr class="memdesc:af8275d390e2114d55449bb4ae2d01d62"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a float into 2 bytes, spanning the range between <em>floatMin</em> and <em>floatMax</em>.  <a href="#af8275d390e2114d55449bb4ae2d01d62"></a><br/></td></tr>
<tr class="separator:af8275d390e2114d55449bb4ae2d01d62"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aab282a3cea68401414d8569f997a5367"><td class="memTemplParams" colspan="2">template&lt;class serializationType , class sourceType &gt; </td></tr>
<tr class="memitem:aab282a3cea68401414d8569f997a5367"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aab282a3cea68401414d8569f997a5367">ReadCasted</a> (sourceType &amp;value)</td></tr>
<tr class="separator:aab282a3cea68401414d8569f997a5367"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a620645af65289abfb244270261060df9"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a620645af65289abfb244270261060df9"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a620645af65289abfb244270261060df9">ReadBitsFromIntegerRange</a> (templateType &amp;value, const templateType minimum, const templateType maximum, bool allowOutsideRange=false)</td></tr>
<tr class="separator:a620645af65289abfb244270261060df9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae2ebc24f3cf193f77d7cd4c3e1eaf22f"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ae2ebc24f3cf193f77d7cd4c3e1eaf22f"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ae2ebc24f3cf193f77d7cd4c3e1eaf22f">ReadBitsFromIntegerRange</a> (templateType &amp;value, const templateType minimum, const templateType maximum, const int requiredBits, bool allowOutsideRange=false)</td></tr>
<tr class="separator:ae2ebc24f3cf193f77d7cd4c3e1eaf22f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aaa9b48a07801cb8628dd5523a275a917"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:aaa9b48a07801cb8628dd5523a275a917"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aaa9b48a07801cb8628dd5523a275a917">ReadNormVector</a> (templateType &amp;x, templateType &amp;y, templateType &amp;z)</td></tr>
<tr class="memdesc:aaa9b48a07801cb8628dd5523a275a917"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes.  <a href="#aaa9b48a07801cb8628dd5523a275a917"></a><br/></td></tr>
<tr class="separator:aaa9b48a07801cb8628dd5523a275a917"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1c0d350e53bc70d3d24def9b6bbf62ba"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a1c0d350e53bc70d3d24def9b6bbf62ba"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1c0d350e53bc70d3d24def9b6bbf62ba">ReadVector</a> (templateType &amp;x, templateType &amp;y, templateType &amp;z)</td></tr>
<tr class="memdesc:a1c0d350e53bc70d3d24def9b6bbf62ba"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read 3 floats or doubles, using 10 bytes, where those float or doubles comprise a vector.  <a href="#a1c0d350e53bc70d3d24def9b6bbf62ba"></a><br/></td></tr>
<tr class="separator:a1c0d350e53bc70d3d24def9b6bbf62ba"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad6ec569c23a95f8ee46ec36c4b8303da"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:ad6ec569c23a95f8ee46ec36c4b8303da"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad6ec569c23a95f8ee46ec36c4b8303da">ReadNormQuat</a> (templateType &amp;w, templateType &amp;x, templateType &amp;y, templateType &amp;z)</td></tr>
<tr class="memdesc:ad6ec569c23a95f8ee46ec36c4b8303da"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes.  <a href="#ad6ec569c23a95f8ee46ec36c4b8303da"></a><br/></td></tr>
<tr class="separator:ad6ec569c23a95f8ee46ec36c4b8303da"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a542c53992e9896cddb7a1bd96bce06ff"><td class="memTemplParams" colspan="2">template&lt;class templateType &gt; </td></tr>
<tr class="memitem:a542c53992e9896cddb7a1bd96bce06ff"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a542c53992e9896cddb7a1bd96bce06ff">ReadOrthMatrix</a> (templateType &amp;m00, templateType &amp;m01, templateType &amp;m02, templateType &amp;m10, templateType &amp;m11, templateType &amp;m12, templateType &amp;m20, templateType &amp;m21, templateType &amp;m22)</td></tr>
<tr class="memdesc:a542c53992e9896cddb7a1bd96bce06ff"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read an orthogonal matrix from a quaternion, reading 3 components of the quaternion in 2 bytes each and extrapolatig the 4th.  <a href="#a542c53992e9896cddb7a1bd96bce06ff"></a><br/></td></tr>
<tr class="separator:a542c53992e9896cddb7a1bd96bce06ff"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aaa64a4efffbfc9f5e527061bb82126b8"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aaa64a4efffbfc9f5e527061bb82126b8"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aaa64a4efffbfc9f5e527061bb82126b8">ResetReadPointer</a> (void)</td></tr>
<tr class="memdesc:aaa64a4efffbfc9f5e527061bb82126b8"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the read pointer back to the beginning of your data. <br/></td></tr>
<tr class="separator:aaa64a4efffbfc9f5e527061bb82126b8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9254b23b2873496aab84d2637d7488ee"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a9254b23b2873496aab84d2637d7488ee"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a9254b23b2873496aab84d2637d7488ee">ResetWritePointer</a> (void)</td></tr>
<tr class="memdesc:a9254b23b2873496aab84d2637d7488ee"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the write pointer back to the beginning of your data. <br/></td></tr>
<tr class="separator:a9254b23b2873496aab84d2637d7488ee"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8492d958d2527a14813cc1a22a71b83a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a8492d958d2527a14813cc1a22a71b83a"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8492d958d2527a14813cc1a22a71b83a">AssertStreamEmpty</a> (void)</td></tr>
<tr class="memdesc:a8492d958d2527a14813cc1a22a71b83a"><td class="mdescLeft">&#160;</td><td class="mdescRight">This is good to call when you are done with the stream to make sure you didn't leave any data left over void. <br/></td></tr>
<tr class="separator:a8492d958d2527a14813cc1a22a71b83a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a74cf3e238c0925fdbeb7b792a2f79626"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a74cf3e238c0925fdbeb7b792a2f79626"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a74cf3e238c0925fdbeb7b792a2f79626">PrintBits</a> (char *out) const </td></tr>
<tr class="memdesc:a74cf3e238c0925fdbeb7b792a2f79626"><td class="mdescLeft">&#160;</td><td class="mdescRight">RAKNET_DEBUG_PRINTF the bits in the stream. Great for debugging. <br/></td></tr>
<tr class="separator:a74cf3e238c0925fdbeb7b792a2f79626"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1952b3b3007b120fdd143f87311a98a2"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1952b3b3007b120fdd143f87311a98a2">IgnoreBits</a> (const BitSize_t numberOfBits)</td></tr>
<tr class="memdesc:a1952b3b3007b120fdd143f87311a98a2"><td class="mdescLeft">&#160;</td><td class="mdescRight">Ignore data we don't intend to read.  <a href="#a1952b3b3007b120fdd143f87311a98a2"></a><br/></td></tr>
<tr class="separator:a1952b3b3007b120fdd143f87311a98a2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a26310ba75436c24a1272e65da6a90a1e"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a26310ba75436c24a1272e65da6a90a1e">IgnoreBytes</a> (const unsigned int numberOfBytes)</td></tr>
<tr class="memdesc:a26310ba75436c24a1272e65da6a90a1e"><td class="mdescLeft">&#160;</td><td class="mdescRight">Ignore data we don't intend to read.  <a href="#a26310ba75436c24a1272e65da6a90a1e"></a><br/></td></tr>
<tr class="separator:a26310ba75436c24a1272e65da6a90a1e"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa56ebc6a1381369ddc2a6d7821512d7e"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aa56ebc6a1381369ddc2a6d7821512d7e">SetWriteOffset</a> (const BitSize_t offset)</td></tr>
<tr class="memdesc:aa56ebc6a1381369ddc2a6d7821512d7e"><td class="mdescLeft">&#160;</td><td class="mdescRight">Move the write pointer to a position on the array.  <a href="#aa56ebc6a1381369ddc2a6d7821512d7e"></a><br/></td></tr>
<tr class="separator:aa56ebc6a1381369ddc2a6d7821512d7e"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a403d4d6ada2fd98bc78943124fc1276a"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a403d4d6ada2fd98bc78943124fc1276a"></a>
BitSize_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a403d4d6ada2fd98bc78943124fc1276a">GetNumberOfBitsUsed</a> (void) const </td></tr>
<tr class="memdesc:a403d4d6ada2fd98bc78943124fc1276a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the length in bits of the stream. <br/></td></tr>
<tr class="separator:a403d4d6ada2fd98bc78943124fc1276a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a98478b4da2e29d5923c0ae80bda76f97"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a98478b4da2e29d5923c0ae80bda76f97"></a>
BitSize_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a98478b4da2e29d5923c0ae80bda76f97">GetNumberOfBytesUsed</a> (void) const </td></tr>
<tr class="memdesc:a98478b4da2e29d5923c0ae80bda76f97"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the length in bytes of the stream. <br/></td></tr>
<tr class="separator:a98478b4da2e29d5923c0ae80bda76f97"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab4fa9312c1d16efd18059e38569c4bb1"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ab4fa9312c1d16efd18059e38569c4bb1"></a>
BitSize_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ab4fa9312c1d16efd18059e38569c4bb1">GetReadOffset</a> (void) const </td></tr>
<tr class="memdesc:ab4fa9312c1d16efd18059e38569c4bb1"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of bits into the stream that we have read. <br/></td></tr>
<tr class="separator:ab4fa9312c1d16efd18059e38569c4bb1"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad7a63454d1e1f26c659c3ebb65bd76ba"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ad7a63454d1e1f26c659c3ebb65bd76ba"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad7a63454d1e1f26c659c3ebb65bd76ba">SetReadOffset</a> (const BitSize_t newReadOffset)</td></tr>
<tr class="memdesc:ad7a63454d1e1f26c659c3ebb65bd76ba"><td class="mdescLeft">&#160;</td><td class="mdescRight">Sets the read bit index. <br/></td></tr>
<tr class="separator:ad7a63454d1e1f26c659c3ebb65bd76ba"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a7a853a0e55000f302b3af27d20ae1dea"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a7a853a0e55000f302b3af27d20ae1dea"></a>
BitSize_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a7a853a0e55000f302b3af27d20ae1dea">GetNumberOfUnreadBits</a> (void) const </td></tr>
<tr class="memdesc:a7a853a0e55000f302b3af27d20ae1dea"><td class="mdescLeft">&#160;</td><td class="mdescRight">Returns the number of bits left in the stream that haven't been read. <br/></td></tr>
<tr class="separator:a7a853a0e55000f302b3af27d20ae1dea"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8471c4c11d6cc08bf713c8f8273d86b0"><td class="memItemLeft" align="right" valign="top">BitSize_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8471c4c11d6cc08bf713c8f8273d86b0">CopyData</a> (unsigned char **_data) const </td></tr>
<tr class="memdesc:a8471c4c11d6cc08bf713c8f8273d86b0"><td class="mdescLeft">&#160;</td><td class="mdescRight">Makes a copy of the internal data for you <em>_data</em> will point to the stream. Partial bytes are left aligned.  <a href="#a8471c4c11d6cc08bf713c8f8273d86b0"></a><br/></td></tr>
<tr class="separator:a8471c4c11d6cc08bf713c8f8273d86b0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2e201444796178e5074083b6d09bd221"><td class="memItemLeft" align="right" valign="top">unsigned char *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a2e201444796178e5074083b6d09bd221">GetData</a> (void) const </td></tr>
<tr class="separator:a2e201444796178e5074083b6d09bd221"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6357c08afed23e2e857c418cbbb3a29a"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a6357c08afed23e2e857c418cbbb3a29a">WriteBits</a> (const unsigned char *inByteArray, BitSize_t numberOfBitsToWrite, const bool rightAlignedBits=true)</td></tr>
<tr class="memdesc:a6357c08afed23e2e857c418cbbb3a29a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write numberToWrite bits from the input source.  <a href="#a6357c08afed23e2e857c418cbbb3a29a"></a><br/></td></tr>
<tr class="separator:a6357c08afed23e2e857c418cbbb3a29a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:abcd8b1c73408fc1e4e8088ca858c0f7a"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#abcd8b1c73408fc1e4e8088ca858c0f7a">WriteAlignedBytes</a> (const unsigned char *inByteArray, const unsigned int numberOfBytesToWrite)</td></tr>
<tr class="memdesc:abcd8b1c73408fc1e4e8088ca858c0f7a"><td class="mdescLeft">&#160;</td><td class="mdescRight">Align the bitstream to the byte boundary and then write the specified number of bits.  <a href="#abcd8b1c73408fc1e4e8088ca858c0f7a"></a><br/></td></tr>
<tr class="separator:abcd8b1c73408fc1e4e8088ca858c0f7a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2ae285a7aaba6f50b5ce8e5bf4163639"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a2ae285a7aaba6f50b5ce8e5bf4163639">WriteAlignedBytesSafe</a> (const char *inByteArray, const unsigned int inputLength, const unsigned int maxBytesToWrite)</td></tr>
<tr class="memdesc:a2ae285a7aaba6f50b5ce8e5bf4163639"><td class="mdescLeft">&#160;</td><td class="mdescRight">Aligns the bitstream, writes inputLength, and writes input. Won't write beyond maxBytesToWrite.  <a href="#a2ae285a7aaba6f50b5ce8e5bf4163639"></a><br/></td></tr>
<tr class="separator:a2ae285a7aaba6f50b5ce8e5bf4163639"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1543023e7a84ecbf58a777aa2071b444"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1543023e7a84ecbf58a777aa2071b444">ReadAlignedBytes</a> (unsigned char *inOutByteArray, const unsigned int numberOfBytesToRead)</td></tr>
<tr class="memdesc:a1543023e7a84ecbf58a777aa2071b444"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read bits, starting at the next aligned bits.  <a href="#a1543023e7a84ecbf58a777aa2071b444"></a><br/></td></tr>
<tr class="separator:a1543023e7a84ecbf58a777aa2071b444"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2fcd3b86367691647f66a81241358fe7"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a2fcd3b86367691647f66a81241358fe7">ReadAlignedBytesSafe</a> (char *inOutByteArray, int &amp;inputLength, const int maxBytesToRead)</td></tr>
<tr class="memdesc:a2fcd3b86367691647f66a81241358fe7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads what was written by WriteAlignedBytesSafe.  <a href="#a2fcd3b86367691647f66a81241358fe7"></a><br/></td></tr>
<tr class="separator:a2fcd3b86367691647f66a81241358fe7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9ada145cbde1fb34dc4187b33ca5b4f6"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a9ada145cbde1fb34dc4187b33ca5b4f6">ReadAlignedBytesSafeAlloc</a> (char **outByteArray, int &amp;inputLength, const unsigned int maxBytesToRead)</td></tr>
<tr class="memdesc:a9ada145cbde1fb34dc4187b33ca5b4f6"><td class="mdescLeft">&#160;</td><td class="mdescRight">Same as <a class="el" href="classRakNet_1_1BitStream.html#a2fcd3b86367691647f66a81241358fe7" title="Reads what was written by WriteAlignedBytesSafe.">ReadAlignedBytesSafe()</a> but allocates the memory for you using new, rather than assuming it is safe to write to.  <a href="#a9ada145cbde1fb34dc4187b33ca5b4f6"></a><br/></td></tr>
<tr class="separator:a9ada145cbde1fb34dc4187b33ca5b4f6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a157d750a205462beb3b418ade252cf19"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a157d750a205462beb3b418ade252cf19">AlignWriteToByteBoundary</a> (void)</td></tr>
<tr class="memdesc:a157d750a205462beb3b418ade252cf19"><td class="mdescLeft">&#160;</td><td class="mdescRight">Align the next write and/or read to a byte boundary.  <a href="#a157d750a205462beb3b418ade252cf19"></a><br/></td></tr>
<tr class="separator:a157d750a205462beb3b418ade252cf19"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aadbbeb19cf6b7fbb5c170ae366d4be30"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aadbbeb19cf6b7fbb5c170ae366d4be30">AlignReadToByteBoundary</a> (void)</td></tr>
<tr class="memdesc:aadbbeb19cf6b7fbb5c170ae366d4be30"><td class="mdescLeft">&#160;</td><td class="mdescRight">Align the next write and/or read to a byte boundary.  <a href="#aadbbeb19cf6b7fbb5c170ae366d4be30"></a><br/></td></tr>
<tr class="separator:aadbbeb19cf6b7fbb5c170ae366d4be30"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a386965784e4352212b047c1c3dcb51f3"><td class="memItemLeft" align="right" valign="top">bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a386965784e4352212b047c1c3dcb51f3">ReadBits</a> (unsigned char *inOutByteArray, BitSize_t numberOfBitsToRead, const bool alignBitsToRight=true)</td></tr>
<tr class="memdesc:a386965784e4352212b047c1c3dcb51f3"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read <em>numberOfBitsToRead</em> bits to the output source.  <a href="#a386965784e4352212b047c1c3dcb51f3"></a><br/></td></tr>
<tr class="separator:a386965784e4352212b047c1c3dcb51f3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad944a6707a90f1727bcc5ac8de2b58bd"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ad944a6707a90f1727bcc5ac8de2b58bd"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad944a6707a90f1727bcc5ac8de2b58bd">Write0</a> (void)</td></tr>
<tr class="memdesc:ad944a6707a90f1727bcc5ac8de2b58bd"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a 0. <br/></td></tr>
<tr class="separator:ad944a6707a90f1727bcc5ac8de2b58bd"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a185c35c9ca1fc58057d9e94a025d3961"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a185c35c9ca1fc58057d9e94a025d3961"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a185c35c9ca1fc58057d9e94a025d3961">Write1</a> (void)</td></tr>
<tr class="memdesc:a185c35c9ca1fc58057d9e94a025d3961"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a 1. <br/></td></tr>
<tr class="separator:a185c35c9ca1fc58057d9e94a025d3961"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a48bf969fc517f2e568ce02c4a859cc27"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a48bf969fc517f2e568ce02c4a859cc27"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a48bf969fc517f2e568ce02c4a859cc27">ReadBit</a> (void)</td></tr>
<tr class="memdesc:a48bf969fc517f2e568ce02c4a859cc27"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reads 1 bit and returns true if that bit is 1 and false if it is 0. <br/></td></tr>
<tr class="separator:a48bf969fc517f2e568ce02c4a859cc27"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a0c4d4693f8fa98c3fa757da57fcb0c5d"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a0c4d4693f8fa98c3fa757da57fcb0c5d"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a0c4d4693f8fa98c3fa757da57fcb0c5d">AssertCopyData</a> (void)</td></tr>
<tr class="memdesc:a0c4d4693f8fa98c3fa757da57fcb0c5d"><td class="mdescLeft">&#160;</td><td class="mdescRight">If we used the constructor version with copy data off, this *makes sure it is set to on and the data pointed to is copied. <br/></td></tr>
<tr class="separator:a0c4d4693f8fa98c3fa757da57fcb0c5d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aba6bd33c456e1593e002207bc3ec5c28"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="aba6bd33c456e1593e002207bc3ec5c28"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aba6bd33c456e1593e002207bc3ec5c28">SetNumberOfBitsAllocated</a> (const BitSize_t lengthInBits)</td></tr>
<tr class="memdesc:aba6bd33c456e1593e002207bc3ec5c28"><td class="mdescLeft">&#160;</td><td class="mdescRight">Use this if you pass a pointer copy to the constructor *(_copyData==false) and want to overallocate to prevent reallocation. <br/></td></tr>
<tr class="separator:aba6bd33c456e1593e002207bc3ec5c28"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8ee4d3114fcce22de87644241dcdd39b"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a8ee4d3114fcce22de87644241dcdd39b"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8ee4d3114fcce22de87644241dcdd39b">AddBitsAndReallocate</a> (const BitSize_t numberOfBitsToWrite)</td></tr>
<tr class="memdesc:a8ee4d3114fcce22de87644241dcdd39b"><td class="mdescLeft">&#160;</td><td class="mdescRight">Reallocates (if necessary) in preparation of writing numberOfBitsToWrite. <br/></td></tr>
<tr class="separator:a8ee4d3114fcce22de87644241dcdd39b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ac554b5dff8da17052d12ed620bb8cf53"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="ac554b5dff8da17052d12ed620bb8cf53"></a>
bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ac554b5dff8da17052d12ed620bb8cf53">Read</a> (char *varString)</td></tr>
<tr class="memdesc:ac554b5dff8da17052d12ed620bb8cf53"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read strings, non reference. <br/></td></tr>
<tr class="separator:ac554b5dff8da17052d12ed620bb8cf53"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1517a13993e3b19f84692db75d1c162f"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1517a13993e3b19f84692db75d1c162f"></a>
void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1517a13993e3b19f84692db75d1c162f">PadWithZeroToByteLength</a> (unsigned int bytes)</td></tr>
<tr class="memdesc:a1517a13993e3b19f84692db75d1c162f"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write zeros until the bitstream is filled up to <em>bytes</em>. <br/></td></tr>
<tr class="separator:a1517a13993e3b19f84692db75d1c162f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a66b52fab9bbf560e6e1f489fcb721606"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:a66b52fab9bbf560e6e1f489fcb721606"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a66b52fab9bbf560e6e1f489fcb721606">Write</a> (const bool &amp;inTemplateVar)</td></tr>
<tr class="memdesc:a66b52fab9bbf560e6e1f489fcb721606"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a bool to a bitstream.  <a href="#a66b52fab9bbf560e6e1f489fcb721606"></a><br/></td></tr>
<tr class="separator:a66b52fab9bbf560e6e1f489fcb721606"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa0e36831cf50b73139527f724520af97"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:aa0e36831cf50b73139527f724520af97"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aa0e36831cf50b73139527f724520af97">Write</a> (const <a class="el" href="structRakNet_1_1SystemAddress.html">SystemAddress</a> &amp;inTemplateVar)</td></tr>
<tr class="memdesc:aa0e36831cf50b73139527f724520af97"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a systemAddress to a bitstream.  <a href="#aa0e36831cf50b73139527f724520af97"></a><br/></td></tr>
<tr class="separator:aa0e36831cf50b73139527f724520af97"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab0c45b04dff683e04916b8da25de8154"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:ab0c45b04dff683e04916b8da25de8154"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ab0c45b04dff683e04916b8da25de8154">Write</a> (const <a class="el" href="classRakNet_1_1RakString.html">RakString</a> &amp;inTemplateVar)</td></tr>
<tr class="memdesc:ab0c45b04dff683e04916b8da25de8154"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a string to a bitstream.  <a href="#ab0c45b04dff683e04916b8da25de8154"></a><br/></td></tr>
<tr class="separator:ab0c45b04dff683e04916b8da25de8154"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad69701ef7d6efe0f69d61ff8287ccb78"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:ad69701ef7d6efe0f69d61ff8287ccb78"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad69701ef7d6efe0f69d61ff8287ccb78">WriteDelta</a> (const bool &amp;currentValue, const bool &amp;lastValue)</td></tr>
<tr class="memdesc:ad69701ef7d6efe0f69d61ff8287ccb78"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a bool delta. Same thing as just calling Write.  <a href="#ad69701ef7d6efe0f69d61ff8287ccb78"></a><br/></td></tr>
<tr class="separator:ad69701ef7d6efe0f69d61ff8287ccb78"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa9f89758b7be3a989c530ebd296c3e78"><td class="memTemplParams" colspan="2"><a class="anchor" id="aa9f89758b7be3a989c530ebd296c3e78"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:aa9f89758b7be3a989c530ebd296c3e78"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aa9f89758b7be3a989c530ebd296c3e78">WriteCompressed</a> (const float &amp;inTemplateVar)</td></tr>
<tr class="memdesc:aa9f89758b7be3a989c530ebd296c3e78"><td class="mdescLeft">&#160;</td><td class="mdescRight">For values between -1 and 1. <br/></td></tr>
<tr class="separator:aa9f89758b7be3a989c530ebd296c3e78"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a96ea1b0e57f1ce372927fbace20f3f88"><td class="memTemplParams" colspan="2"><a class="anchor" id="a96ea1b0e57f1ce372927fbace20f3f88"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:a96ea1b0e57f1ce372927fbace20f3f88"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a96ea1b0e57f1ce372927fbace20f3f88">WriteCompressed</a> (const double &amp;inTemplateVar)</td></tr>
<tr class="memdesc:a96ea1b0e57f1ce372927fbace20f3f88"><td class="mdescLeft">&#160;</td><td class="mdescRight">For values between -1 and 1. <br/></td></tr>
<tr class="separator:a96ea1b0e57f1ce372927fbace20f3f88"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a177d488f81c3c30898ea8b9ef014f759"><td class="memTemplParams" colspan="2"><a class="anchor" id="a177d488f81c3c30898ea8b9ef014f759"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:a177d488f81c3c30898ea8b9ef014f759"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a177d488f81c3c30898ea8b9ef014f759">WriteCompressed</a> (const <a class="el" href="classRakNet_1_1RakString.html">RakString</a> &amp;inTemplateVar)</td></tr>
<tr class="memdesc:a177d488f81c3c30898ea8b9ef014f759"><td class="mdescLeft">&#160;</td><td class="mdescRight">Compress the string. <br/></td></tr>
<tr class="separator:a177d488f81c3c30898ea8b9ef014f759"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8f5f7b8b48221334644d4f50ee6d5762"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:a8f5f7b8b48221334644d4f50ee6d5762"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8f5f7b8b48221334644d4f50ee6d5762">WriteCompressedDelta</a> (const bool &amp;currentValue, const bool &amp;lastValue)</td></tr>
<tr class="memdesc:a8f5f7b8b48221334644d4f50ee6d5762"><td class="mdescLeft">&#160;</td><td class="mdescRight">Write a bool delta. Same thing as just calling Write.  <a href="#a8f5f7b8b48221334644d4f50ee6d5762"></a><br/></td></tr>
<tr class="separator:a8f5f7b8b48221334644d4f50ee6d5762"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a8cf066d10aafd4e935dd1bbced77a1a7"><td class="memTemplParams" colspan="2"><a class="anchor" id="a8cf066d10aafd4e935dd1bbced77a1a7"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:a8cf066d10aafd4e935dd1bbced77a1a7"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a8cf066d10aafd4e935dd1bbced77a1a7">WriteCompressedDelta</a> (const bool &amp;currentValue)</td></tr>
<tr class="memdesc:a8cf066d10aafd4e935dd1bbced77a1a7"><td class="mdescLeft">&#160;</td><td class="mdescRight">Save as WriteCompressedDelta(bool currentValue, const templateType &amp;lastValue) when we have an unknown second bool. <br/></td></tr>
<tr class="separator:a8cf066d10aafd4e935dd1bbced77a1a7"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:aa93e4e7cc020377abccf312a0a35029c"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:aa93e4e7cc020377abccf312a0a35029c"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#aa93e4e7cc020377abccf312a0a35029c">Read</a> (bool &amp;outTemplateVar)</td></tr>
<tr class="memdesc:aa93e4e7cc020377abccf312a0a35029c"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a bool from a bitstream.  <a href="#aa93e4e7cc020377abccf312a0a35029c"></a><br/></td></tr>
<tr class="separator:aa93e4e7cc020377abccf312a0a35029c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a4e8909d80334b1db974de6942e33a563"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:a4e8909d80334b1db974de6942e33a563"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a4e8909d80334b1db974de6942e33a563">Read</a> (<a class="el" href="structRakNet_1_1SystemAddress.html">SystemAddress</a> &amp;outTemplateVar)</td></tr>
<tr class="memdesc:a4e8909d80334b1db974de6942e33a563"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a systemAddress from a bitstream.  <a href="#a4e8909d80334b1db974de6942e33a563"></a><br/></td></tr>
<tr class="separator:a4e8909d80334b1db974de6942e33a563"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a377a1aa3f331581e613f6a504ffdd284"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:a377a1aa3f331581e613f6a504ffdd284"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a377a1aa3f331581e613f6a504ffdd284">ReadDelta</a> (bool &amp;outTemplateVar)</td></tr>
<tr class="memdesc:a377a1aa3f331581e613f6a504ffdd284"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a bool from a bitstream.  <a href="#a377a1aa3f331581e613f6a504ffdd284"></a><br/></td></tr>
<tr class="separator:a377a1aa3f331581e613f6a504ffdd284"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a2d9e41a93c48e6538d3ce3a6c7055144"><td class="memTemplParams" colspan="2"><a class="anchor" id="a2d9e41a93c48e6538d3ce3a6c7055144"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:a2d9e41a93c48e6538d3ce3a6c7055144"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a2d9e41a93c48e6538d3ce3a6c7055144">ReadCompressed</a> (float &amp;outTemplateVar)</td></tr>
<tr class="memdesc:a2d9e41a93c48e6538d3ce3a6c7055144"><td class="mdescLeft">&#160;</td><td class="mdescRight">For values between -1 and 1. <br/></td></tr>
<tr class="separator:a2d9e41a93c48e6538d3ce3a6c7055144"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a258dffc96b125c78bb66b0de3ad40f04"><td class="memTemplParams" colspan="2"><a class="anchor" id="a258dffc96b125c78bb66b0de3ad40f04"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:a258dffc96b125c78bb66b0de3ad40f04"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a258dffc96b125c78bb66b0de3ad40f04">ReadCompressed</a> (double &amp;outTemplateVar)</td></tr>
<tr class="memdesc:a258dffc96b125c78bb66b0de3ad40f04"><td class="mdescLeft">&#160;</td><td class="mdescRight">For values between -1 and 1. <br/></td></tr>
<tr class="separator:a258dffc96b125c78bb66b0de3ad40f04"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab2eada178332c4b8067603dfde95dfc0"><td class="memTemplParams" colspan="2"><a class="anchor" id="ab2eada178332c4b8067603dfde95dfc0"></a>
template&lt;&gt; </td></tr>
<tr class="memitem:ab2eada178332c4b8067603dfde95dfc0"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ab2eada178332c4b8067603dfde95dfc0">ReadCompressed</a> (<a class="el" href="classRakNet_1_1RakString.html">RakString</a> &amp;outTemplateVar)</td></tr>
<tr class="memdesc:ab2eada178332c4b8067603dfde95dfc0"><td class="mdescLeft">&#160;</td><td class="mdescRight">For strings. <br/></td></tr>
<tr class="separator:ab2eada178332c4b8067603dfde95dfc0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad83a446bd34af864078b1db95b151a54"><td class="memTemplParams" colspan="2">template&lt;&gt; </td></tr>
<tr class="memitem:ad83a446bd34af864078b1db95b151a54"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#ad83a446bd34af864078b1db95b151a54">ReadCompressedDelta</a> (bool &amp;outTemplateVar)</td></tr>
<tr class="memdesc:ad83a446bd34af864078b1db95b151a54"><td class="mdescLeft">&#160;</td><td class="mdescRight">Read a bool from a bitstream.  <a href="#ad83a446bd34af864078b1db95b151a54"></a><br/></td></tr>
<tr class="separator:ad83a446bd34af864078b1db95b151a54"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-static-methods"></a>
Static Public Member Functions</h2></td></tr>
<tr class="memitem:afc678e70ac2082d65c1b103436ca6b6f"><td class="memItemLeft" align="right" valign="top">static int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#afc678e70ac2082d65c1b103436ca6b6f">NumberOfLeadingZeroes</a> (uint8_t x)</td></tr>
<tr class="separator:afc678e70ac2082d65c1b103436ca6b6f"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1ce179acbb0ca867dacd482013831a30"><td class="memItemLeft" align="right" valign="top"><a class="anchor" id="a1ce179acbb0ca867dacd482013831a30"></a>
static bool&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classRakNet_1_1BitStream.html#a1ce179acbb0ca867dacd482013831a30">DoEndianSwap</a> (void)</td></tr>
<tr class="memdesc:a1ce179acbb0ca867dacd482013831a30"><td class="mdescLeft">&#160;</td><td class="mdescRight">-&mdash; Member function template specialization declarations -&mdash; <br/></td></tr>
<tr class="separator:a1ce179acbb0ca867dacd482013831a30"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<div class="textblock"><p>This class allows you to write and read native types as a string of bits. <a class="el" href="classRakNet_1_1BitStream.html">BitStream</a> is used extensively throughout <a class="el" href="namespaceRakNet.html" title="Simple class to send changes between directories. In essence, a simple autopatcher that can be used f...">RakNet</a> and is designed to be used by users as well. </p>
<dl class="section see"><dt>See Also</dt><dd>BitStreamSample.txt </dd></dl>
</div><h2 class="groupheader">Constructor &amp; Destructor Documentation</h2>
<a class="anchor" id="a47b1c7ce200c4815bd2a42d454244bb4"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">RakNet::BitStream::BitStream </td>
          <td>(</td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>initialBytesToAllocate</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Create the bitstream, with some number of bytes to immediately allocate. </p>
<p>There is no benefit to calling this, unless you know exactly how many bytes you need and it is greater than BITSTREAM_STACK_ALLOCATION_SIZE. In that case all it does is save you one or more realloc calls. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">initialBytesToAllocate</td><td>the number of bytes to pre-allocate. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a04a200eaf5b379cad2e30d5de15a2c9a"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">RakNet::BitStream::BitStream </td>
          <td>(</td>
          <td class="paramtype">unsigned char *&#160;</td>
          <td class="paramname"><em>_data</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>lengthInBytes</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>_copyData</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Initialize the <a class="el" href="classRakNet_1_1BitStream.html">BitStream</a>, immediately setting the data it contains to a predefined pointer. </p>
<p>Set <em>_copyData</em> to true if you want to make an internal copy of the data you are passing. Set it to false to just save a pointer to the data. You shouldn't call Write functions with <em>_copyData</em> as false, as this will write to unallocated memory 99% of the time you will use this function to cast <a class="el" href="structRakNet_1_1Packet.html#a63e46b85c8ca156b205a124e54659614" title="The data from the sender.">Packet::data</a> to a bitstream for reading, in which case you should write something as follows: </p>
<div class="fragment"><div class="line"><a class="code" href="classRakNet_1_1BitStream.html">RakNet::BitStream</a> bs(packet-&gt;data, packet-&gt;length, <span class="keyword">false</span>);</div>
</div><!-- fragment --> <dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">_data</td><td>An array of bytes. </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lengthInBytes</td><td>Size of the <em>_data</em>. </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">_copyData</td><td>true or false to make a copy of <em>_data</em> or not. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<h2 class="groupheader">Member Function Documentation</h2>
<a class="anchor" id="aadbbeb19cf6b7fbb5c170ae366d4be30"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::AlignReadToByteBoundary </td>
          <td>(</td>
          <td class="paramtype">void&#160;</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Align the next write and/or read to a byte boundary. </p>
<p>This can be used to 'waste' bits to byte align for efficiency reasons It can also be used to force coalesced bitstreams to start on byte boundaries so so WriteAlignedBits and ReadAlignedBits both calculate the same offset when aligning. </p>

</div>
</div>
<a class="anchor" id="a157d750a205462beb3b418ade252cf19"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::AlignWriteToByteBoundary </td>
          <td>(</td>
          <td class="paramtype">void&#160;</td>
          <td class="paramname"></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Align the next write and/or read to a byte boundary. </p>
<p>This can be used to 'waste' bits to byte align for efficiency reasons It can also be used to force coalesced bitstreams to start on byte boundaries so so WriteAlignedBits and ReadAlignedBits both calculate the same offset when aligning. </p>

</div>
</div>
<a class="anchor" id="a8471c4c11d6cc08bf713c8f8273d86b0"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">BitSize_t RakNet::BitStream::CopyData </td>
          <td>(</td>
          <td class="paramtype">unsigned char **&#160;</td>
          <td class="paramname"><em>_data</em></td><td>)</td>
          <td> const</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Makes a copy of the internal data for you <em>_data</em> will point to the stream. Partial bytes are left aligned. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[out]</td><td class="paramname">_data</td><td>The allocated copy of <a class="el" href="classRakNet_1_1BitStream.html#a2e201444796178e5074083b6d09bd221">GetData()</a> </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The length in bits of the stream. </dd></dl>

</div>
</div>
<a class="anchor" id="a2e201444796178e5074083b6d09bd221"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">unsigned char* RakNet::BitStream::GetData </td>
          <td>(</td>
          <td class="paramtype">void&#160;</td>
          <td class="paramname"></td><td>)</td>
          <td> const</td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">
<p>Gets the data that <a class="el" href="classRakNet_1_1BitStream.html">BitStream</a> is writing to / reading from. Partial bytes are left aligned. </p>
<dl class="section return"><dt>Returns</dt><dd>A pointer to the internal state </dd></dl>

</div>
</div>
<a class="anchor" id="a1952b3b3007b120fdd143f87311a98a2"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::IgnoreBits </td>
          <td>(</td>
          <td class="paramtype">const BitSize_t&#160;</td>
          <td class="paramname"><em>numberOfBits</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Ignore data we don't intend to read. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBits</td><td>The number of bits to ignore </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a26310ba75436c24a1272e65da6a90a1e"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::IgnoreBytes </td>
          <td>(</td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>numberOfBytes</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Ignore data we don't intend to read. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBits</td><td>The number of bytes to ignore </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="afc678e70ac2082d65c1b103436ca6b6f"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">static int RakNet::BitStream::NumberOfLeadingZeroes </td>
          <td>(</td>
          <td class="paramtype">uint8_t&#160;</td>
          <td class="paramname"><em>x</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">static</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">
<p>Get the number of leading zeros for a number </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>Number to test </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a865bd246780b10e2b9d7c1bc13044343"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Read </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read any integral type from a bitstream. </p>
<p>Read any integral type from a bitstream. Define __BITSTREAM_NATIVE_END if you need endian swapping.</p>
<p>Define __BITSTREAM_NATIVE_END if you need endian swapping. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure.</dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a025f73d57a5ebe8fb6393eca5f3616df"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Read </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classRakNet_1_1BitStream.html">BitStream</a> *&#160;</td>
          <td class="paramname"><em>bitStream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">BitSize_t&#160;</td>
          <td class="paramname"><em>numberOfBits</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read one bitstream to another. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBits</td><td>bits to read </td></tr>
    <tr><td class="paramdir"></td><td class="paramname">bitStream</td><td>the bitstream to read into from </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="a25b53ddc6f6bc9a1e0c01cb677a3c6d1"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Read </td>
          <td>(</td>
          <td class="paramtype">char *&#160;</td>
          <td class="paramname"><em>output</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>numberOfBytes</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read an array or casted stream of byte. </p>
<p>The array is raw data. There is no automatic endian conversion with this function </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">output</td><td>The result byte array. It should be larger than <em>numberOfBytes</em>. </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBytes</td><td>The number of byte to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success false if there is some missing bytes. </dd></dl>

</div>
</div>
<a class="anchor" id="aa93e4e7cc020377abccf312a0a35029c"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Read </td>
          <td>(</td>
          <td class="paramtype">bool &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read a bool from a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a4e8909d80334b1db974de6942e33a563"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Read </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="structRakNet_1_1SystemAddress.html">SystemAddress</a> &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read a systemAddress from a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a1543023e7a84ecbf58a777aa2071b444"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadAlignedBytes </td>
          <td>(</td>
          <td class="paramtype">unsigned char *&#160;</td>
          <td class="paramname"><em>inOutByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>numberOfBytesToRead</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read bits, starting at the next aligned bits. </p>
<p>Note that the modulus 8 starting offset of the sequence must be the same as was used with WriteBits. This will be a problem with packet coalescence unless you byte align the coalesced packets. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutByteArray</td><td>The byte array larger than <em>numberOfBytesToRead</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBytesToRead</td><td>The number of byte to read from the internal state </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if there is enough byte. </dd></dl>

</div>
</div>
<a class="anchor" id="a2fcd3b86367691647f66a81241358fe7"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadAlignedBytesSafe </td>
          <td>(</td>
          <td class="paramtype">char *&#160;</td>
          <td class="paramname"><em>inOutByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int &amp;&#160;</td>
          <td class="paramname"><em>inputLength</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const int&#160;</td>
          <td class="paramname"><em>maxBytesToRead</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Reads what was written by WriteAlignedBytesSafe. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutByteArray</td><td>The data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">maxBytesToRead</td><td>Maximum number of bytes to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="a9ada145cbde1fb34dc4187b33ca5b4f6"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadAlignedBytesSafeAlloc </td>
          <td>(</td>
          <td class="paramtype">char **&#160;</td>
          <td class="paramname"><em>outByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">int &amp;&#160;</td>
          <td class="paramname"><em>inputLength</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>maxBytesToRead</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Same as <a class="el" href="classRakNet_1_1BitStream.html#a2fcd3b86367691647f66a81241358fe7" title="Reads what was written by WriteAlignedBytesSafe.">ReadAlignedBytesSafe()</a> but allocates the memory for you using new, rather than assuming it is safe to write to. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outByteArray</td><td>outByteArray will be deleted if it is not a pointer to 0 </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="a386965784e4352212b047c1c3dcb51f3"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadBits </td>
          <td>(</td>
          <td class="paramtype">unsigned char *&#160;</td>
          <td class="paramname"><em>inOutByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">BitSize_t&#160;</td>
          <td class="paramname"><em>numberOfBitsToRead</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const bool&#160;</td>
          <td class="paramname"><em>alignBitsToRight</em> = <code>true</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read <em>numberOfBitsToRead</em> bits to the output source. </p>
<p>alignBitsToRight should be set to true to convert internal bitstream data to userdata. It should be false if you used WriteBits with rightAlignedBits false </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutByteArray</td><td>The resulting bits array </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBitsToRead</td><td>The number of bits to read </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">alignBitsToRight</td><td>if true bits will be right aligned. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if there is enough bits to read </dd></dl>

</div>
</div>
<a class="anchor" id="a620645af65289abfb244270261060df9"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadBitsFromIntegerRange </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>value</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>minimum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>maximum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>allowOutsideRange</em> = <code>false</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<p>Given the minimum and maximum values for an integer type, figure out the minimum number of bits to represent the range Then read only those bits </p>
<dl class="section note"><dt>Note</dt><dd>A static is used so that the required number of bits for (maximum-minimum) is only calculated once. This does require that <em>minimum</em> and  are fixed values for a given line of code for the life of the program </dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">value</td><td>Integer value to read, which should be between <em>minimum</em> and <em>maximum</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">minimum</td><td>Minimum value of <em>value</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">maximum</td><td>Maximum value of <em>value</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">allowOutsideRange</td><td>If true, all sends will take an extra bit, however value can deviate from outside <em>minimum</em> and <em>maximum</em>. If false, will assert if the value deviates. This should match the corresponding value passed to <a class="el" href="classRakNet_1_1BitStream.html#acc0d0bb96142a302385613d44e66558b" title="Write any integral type to a bitstream.">Write()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ae2ebc24f3cf193f77d7cd4c3e1eaf22f"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadBitsFromIntegerRange </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>value</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>minimum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>maximum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const int&#160;</td>
          <td class="paramname"><em>requiredBits</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>allowOutsideRange</em> = <code>false</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">requiredBits</td><td>Primarily for internal use, called from above function() after calculating number of bits needed to represent maximum-minimum </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="aab282a3cea68401414d8569f997a5367"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class serializationType , class sourceType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadCasted </td>
          <td>(</td>
          <td class="paramtype">sourceType &amp;&#160;</td>
          <td class="paramname"><em>value</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">
<p>Read one type serialized to another (smaller) type, to save bandwidth serializationType should be uint8_t, uint16_t, uint24_t, or uint32_t Example: int num; ReadCasted&lt;uint8_t&gt;(num); would read 1 bytefrom the stream, and put the value in an integer </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">value</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="acc394f439d9112328f92e7b22d116e5a"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadCompressed </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read any integral type from a bitstream. </p>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure.</dd></dl>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a099c2c8fb1b5321aacb5bded88a8f300"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadCompressedDelta </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read any integral type from a bitstream. </p>
<p>If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. the current value will be updated. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte ReadCompressedDelta is only valid from a previous call to WriteDelta </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure.</dd></dl>
<p>If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. the current value will be updated. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte ReadCompressedDelta is only valid from a previous call to WriteDelta </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ad83a446bd34af864078b1db95b151a54"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadCompressedDelta </td>
          <td>(</td>
          <td class="paramtype">bool &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read a bool from a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ad19904647a86e54757a4a740d1275b00"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadDelta </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read any integral type from a bitstream. </p>
<p>If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. ReadDelta is only valid from a previous call to WriteDelta </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure.</dd></dl>
<p>If the written value differed from the value compared against in the write function, var will be updated. Otherwise it will retain the current value. ReadDelta is only valid from a previous call to WriteDelta </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a377a1aa3f331581e613f6a504ffdd284"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadDelta </td>
          <td>(</td>
          <td class="paramtype">bool &amp;&#160;</td>
          <td class="paramname"><em>outTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Read a bool from a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outTemplateVar</td><td>The value to read </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="af8275d390e2114d55449bb4ae2d01d62"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadFloat16 </td>
          <td>(</td>
          <td class="paramtype">float &amp;&#160;</td>
          <td class="paramname"><em>outFloat</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>floatMin</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>floatMax</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read a float into 2 bytes, spanning the range between <em>floatMin</em> and <em>floatMax</em>. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">outFloat</td><td>The float to read </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">floatMin</td><td>Predetermined minimum value of f </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">floatMax</td><td>Predetermined maximum value of f </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ad6ec569c23a95f8ee46ec36c4b8303da"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadNormQuat </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">w</td><td>w </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="aaa9b48a07801cb8628dd5523a275a917"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadNormVector </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes. </p>
<p>Will further compress y or z axis aligned vectors. Accurate to 1/32767.5. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="a542c53992e9896cddb7a1bd96bce06ff"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadOrthMatrix </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m00</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m01</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m02</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m10</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m11</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m12</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m20</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m21</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m22</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read an orthogonal matrix from a quaternion, reading 3 components of the quaternion in 2 bytes each and extrapolatig the 4th. </p>
<p>Use 6 bytes instead of 36 Lossy, although the result is renormalized </p>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="a1c0d350e53bc70d3d24def9b6bbf62ba"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::ReadVector </td>
          <td>(</td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Read 3 floats or doubles, using 10 bytes, where those float or doubles comprise a vector. </p>
<p>Loses accuracy to about 3/10ths and only saves 2 bytes, so only use if accuracy is not important. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="adf95af1e57ce9a5386ab6a620ffd593b"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Serialize </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>inOutTemplateVar</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize any integral type to/from a bitstream. </p>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="ad2e3ec310191a69b9bba227a72e65537"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::Serialize </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">char *&#160;</td>
          <td class="paramname"><em>inOutByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>numberOfBytes</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize an array or casted stream or raw data. This does NOT do endian swapping. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutByteArray</td><td>a byte buffer </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBytes</td><td>the size of <em>input</em> in bytes </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="a25c0f31d16b211a2aa7cdb3ec594cbf9"></a>
<div class="memitem">
<div class="memproto">
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeBits </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">unsigned char *&#160;</td>
          <td class="paramname"><em>inOutByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const BitSize_t&#160;</td>
          <td class="paramname"><em>numberOfBitsToSerialize</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const bool&#160;</td>
          <td class="paramname"><em>rightAlignedBits</em> = <code>true</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize numberToSerialize bits to/from the input. </p>
<p>Right aligned data means in the case of a partial byte, the bits are aligned from the right (bit 0) rather than the left (as in the normal internal representation) You would set this to true when writing user data, and false when copying bitstream data, such as writing one bitstream to another </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutByteArray</td><td>The data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBitsToSerialize</td><td>The number of bits to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">rightAlignedBits</td><td>if true data will be right aligned </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="a9cfb0266bf435e0bba8b221f089a4aec"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeBitsFromIntegerRange </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>value</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>minimum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>maximum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>allowOutsideRange</em> = <code>false</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<p>Given the minimum and maximum values for an integer type, figure out the minimum number of bits to represent the range Then serialize only those bits </p>
<dl class="section note"><dt>Note</dt><dd>A static is used so that the required number of bits for (maximum-minimum) is only calculated once. This does require that <em>minimum</em> and  are fixed values for a given line of code for the life of the program </dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">value</td><td>Integer value to write, which should be between <em>minimum</em> and <em>maximum</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">minimum</td><td>Minimum value of <em>value</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">maximum</td><td>Maximum value of <em>value</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">allowOutsideRange</td><td>If true, all sends will take an extra bit, however value can deviate from outside <em>minimum</em> and <em>maximum</em>. If false, will assert if the value deviates </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a91e811bf0d8447faedc96261920944cd"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeBitsFromIntegerRange </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>value</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>minimum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>maximum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const int&#160;</td>
          <td class="paramname"><em>requiredBits</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>allowOutsideRange</em> = <code>false</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">requiredBits</td><td>Primarily for internal use, called from above function() after calculating number of bits needed to represent maximum-minimum </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a3615fc88c34f910085e0f94a6231926b"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class serializationType , class sourceType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeCasted </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">sourceType &amp;&#160;</td>
          <td class="paramname"><em>value</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<p>Serialize one type casted to another (smaller) type, to save bandwidth serializationType should be uint8_t, uint16_t, uint24_t, or uint32_t Example: int num=53; SerializeCasted&lt;uint8_t&gt;(true, num); would use 1 byte to write what would otherwise be an integer (4 or 8 bytes) </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">value</td><td>The value to serialize </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a5fdf11345fb4e998d411b87426648a36"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeCompressed </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>inOutTemplateVar</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize any integral type to/from a bitstream. </p>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="a8a1991ab41173693f8e9c0e78c9ad2a3"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeCompressedDelta </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>inOutCurrentValue</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>lastValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize any integral type to/from a bitstream. </p>
<p>If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutCurrentValue</td><td>The current value to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lastValue</td><td>The last value to compare against. Only used if <em>writeToBitstream</em> is true. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="ad1ca9bf6bb61905e43003097d7af79fe"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeCompressedDelta </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>inOutTemplateVar</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Save as SerializeCompressedDelta(templateType &amp;currentValue, const templateType &amp;lastValue) when we have an unknown second parameter. </p>
<dl class="section return"><dt>Returns</dt><dd>true on data read. False on insufficient data in bitstream </dd></dl>

</div>
</div>
<a class="anchor" id="a6aab79184deb91907b7bc8934ca45bc2"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeDelta </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>inOutCurrentValue</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>lastValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize any integral type to/from a bitstream. </p>
<p>If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutCurrentValue</td><td>The current value to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lastValue</td><td>The last value to compare against. Only used if <em>writeToBitstream</em> is true. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="ab1cc6838ab5b4477ac7a4021bb1356c3"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeDelta </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>inOutCurrentValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional version of SerializeDelta when you don't know what the last value is, or there is no last value. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutCurrentValue</td><td>The current value to write </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="a1aebab1c543acd21742f380c95255365"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeFloat16 </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float &amp;&#160;</td>
          <td class="paramname"><em>inOutFloat</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>floatMin</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>floatMax</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Serialize a float into 2 bytes, spanning the range between <em>floatMin</em> and <em>floatMax</em>. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inOutFloat</td><td>The float to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">floatMin</td><td>Predetermined minimum value of f </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">floatMax</td><td>Predetermined maximum value of f </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a03953490ce2c0fbc5cebb67fdebdb75d"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeNormQuat </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">w</td><td>w </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="a1e357618f04ee5166fe74a9738a28b82"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeNormVector </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes. </p>
<p>Will further compress y or z axis aligned vectors. Accurate to 1/32767.5. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="ad45063562f20be6154c17bef523ac846"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeOrthMatrix </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m00</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m01</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m02</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m10</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m11</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m12</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m20</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m21</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>m22</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each. </p>
<p>Use 6 bytes instead of 36 Lossy, although the result is renormalized </p>
<dl class="section return"><dt>Returns</dt><dd>true on success, false on failure. </dd></dl>

</div>
</div>
<a class="anchor" id="ad39a138bf295277ed6f804d6d2d5d9fb"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool RakNet::BitStream::SerializeVector </td>
          <td>(</td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>writeToBitstream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType &amp;&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Bidirectional serialize/deserialize a vector, using 10 bytes instead of 12. </p>
<p>Loses accuracy to about 3/10ths and only saves 2 bytes, so only use if accuracy is not important. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">writeToBitstream</td><td>true to write from your data to this bitstream. False to read from this bitstream and write to your data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>true if <em>writeToBitstream</em> is true. true if <em>writeToBitstream</em> is false and the read was successful. false if <em>writeToBitstream</em> is false and the read was not successful. </dd></dl>

</div>
</div>
<a class="anchor" id="aa56ebc6a1381369ddc2a6d7821512d7e"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::SetWriteOffset </td>
          <td>(</td>
          <td class="paramtype">const BitSize_t&#160;</td>
          <td class="paramname"><em>offset</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Move the write pointer to a position on the array. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">offset</td><td>the offset from the start of the array. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section attention"><dt>Attention</dt><dd></dd></dl>
<p>Dangerous if you don't know what you are doing! For efficiency reasons you can only write mid-stream if your data is byte aligned. </p>

</div>
</div>
<a class="anchor" id="acc0d0bb96142a302385613d44e66558b"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::Write </td>
          <td>(</td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>inTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write any integral type to a bitstream. </p>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a0c6e2624a5960f9ac40d4072a6e607e5"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::Write </td>
          <td>(</td>
          <td class="paramtype">const char *&#160;</td>
          <td class="paramname"><em>inputByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>numberOfBytes</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write an array or casted stream or raw data. This does NOT do endian swapping. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inputByteArray</td><td>a byte buffer </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBytes</td><td>the size of <em>input</em> in bytes </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a26624b5669df1c38f6dd6dabf4c1b769"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::Write </td>
          <td>(</td>
          <td class="paramtype"><a class="el" href="classRakNet_1_1BitStream.html">BitStream</a> *&#160;</td>
          <td class="paramname"><em>bitStream</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">BitSize_t&#160;</td>
          <td class="paramname"><em>numberOfBits</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write one bitstream to another. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBits</td><td>bits to write </td></tr>
    <tr><td class="paramdir"></td><td class="paramname">bitStream</td><td>the bitstream to copy from </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a66b52fab9bbf560e6e1f489fcb721606"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::Write </td>
          <td>(</td>
          <td class="paramtype">const bool &amp;&#160;</td>
          <td class="paramname"><em>inTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write a bool to a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="aa0e36831cf50b73139527f724520af97"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::Write </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="structRakNet_1_1SystemAddress.html">SystemAddress</a> &amp;&#160;</td>
          <td class="paramname"><em>inTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write a systemAddress to a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ab0c45b04dff683e04916b8da25de8154"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::Write </td>
          <td>(</td>
          <td class="paramtype">const <a class="el" href="classRakNet_1_1RakString.html">RakString</a> &amp;&#160;</td>
          <td class="paramname"><em>inTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write a string to a bitstream. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">var</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="abcd8b1c73408fc1e4e8088ca858c0f7a"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteAlignedBytes </td>
          <td>(</td>
          <td class="paramtype">const unsigned char *&#160;</td>
          <td class="paramname"><em>inByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>numberOfBytesToWrite</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Align the bitstream to the byte boundary and then write the specified number of bits. </p>
<p>This is faster than WriteBits but wastes the bits to do the alignment and requires you to call ReadAlignedBits at the corresponding read position. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inByteArray</td><td>The data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBytesToWrite</td><td>The size of input. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a2ae285a7aaba6f50b5ce8e5bf4163639"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteAlignedBytesSafe </td>
          <td>(</td>
          <td class="paramtype">const char *&#160;</td>
          <td class="paramname"><em>inByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>inputLength</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const unsigned int&#160;</td>
          <td class="paramname"><em>maxBytesToWrite</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Aligns the bitstream, writes inputLength, and writes input. Won't write beyond maxBytesToWrite. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inByteArray</td><td>The data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">inputLength</td><td>The size of input. </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">maxBytesToWrite</td><td>Max bytes to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a6357c08afed23e2e857c418cbbb3a29a"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteBits </td>
          <td>(</td>
          <td class="paramtype">const unsigned char *&#160;</td>
          <td class="paramname"><em>inByteArray</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">BitSize_t&#160;</td>
          <td class="paramname"><em>numberOfBitsToWrite</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const bool&#160;</td>
          <td class="paramname"><em>rightAlignedBits</em> = <code>true</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write numberToWrite bits from the input source. </p>
<p>Right aligned data means in the case of a partial byte, the bits are aligned from the right (bit 0) rather than the left (as in the normal internal representation) You would set this to true when writing user data, and false when copying bitstream data, such as writing one bitstream to another. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inByteArray</td><td>The data </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">numberOfBitsToWrite</td><td>The number of bits to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">rightAlignedBits</td><td>if true data will be right aligned </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a7e9345107dfe25bfe800aa17826a77b4"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteBitsFromIntegerRange </td>
          <td>(</td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>value</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>minimum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>maximum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>allowOutsideRange</em> = <code>false</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<p>Given the minimum and maximum values for an integer type, figure out the minimum number of bits to represent the range Then write only those bits </p>
<dl class="section note"><dt>Note</dt><dd>A static is used so that the required number of bits for (maximum-minimum) is only calculated once. This does require that <em>minimum</em> and  are fixed values for a given line of code for the life of the program </dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">value</td><td>Integer value to write, which should be between <em>minimum</em> and <em>maximum</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">minimum</td><td>Minimum value of <em>value</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">maximum</td><td>Maximum value of <em>value</em> </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">allowOutsideRange</td><td>If true, all sends will take an extra bit, however value can deviate from outside <em>minimum</em> and <em>maximum</em>. If false, will assert if the value deviates. This should match the corresponding value passed to <a class="el" href="classRakNet_1_1BitStream.html#a865bd246780b10e2b9d7c1bc13044343" title="Read any integral type from a bitstream.">Read()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a4f0064de4e5e34478bdf43623c8d41a1"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteBitsFromIntegerRange </td>
          <td>(</td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>value</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>minimum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType&#160;</td>
          <td class="paramname"><em>maximum</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const int&#160;</td>
          <td class="paramname"><em>requiredBits</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">bool&#160;</td>
          <td class="paramname"><em>allowOutsideRange</em> = <code>false</code>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">requiredBits</td><td>Primarily for internal use, called from above function() after calculating number of bits needed to represent maximum-minimum </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a13ecfa7830db77b09a1d121bffdccb67"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class destinationType , class sourceType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteCasted </td>
          <td>(</td>
          <td class="paramtype">const sourceType &amp;&#160;</td>
          <td class="paramname"><em>value</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">
<p>Write one type serialized as another (smaller) type, to save bandwidth serializationType should be uint8_t, uint16_t, uint24_t, or uint32_t Example: int num=53; WriteCasted&lt;uint8_t&gt;(num); would use 1 byte to write what would otherwise be an integer (4 or 8 bytes) </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">value</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ac32700a1c6f26d15890470dba1532ef4"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteCompressed </td>
          <td>(</td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>inTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write any integral type to a bitstream. </p>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inTemplateVar</td><td>The value to write</td></tr>
  </table>
  </dd>
</dl>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a1f8aab299cf0eb021802ed8671844948"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteCompressedDelta </td>
          <td>(</td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>currentValue</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>lastValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write any integral type to a bitstream. </p>
<p>If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written For floating point, this is lossy, using 2 bytes for a float and 4 for a double. The range must be between -1 and +1. For non-floating point, this is lossless, but only has benefit if you use less than half the bits of the type If you are not using __BITSTREAM_NATIVE_END the opposite is true for types larger than 1 byte </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">currentValue</td><td>The current value to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lastValue</td><td>The last value to compare against </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a8f5f7b8b48221334644d4f50ee6d5762"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteCompressedDelta </td>
          <td>(</td>
          <td class="paramtype">const bool &amp;&#160;</td>
          <td class="paramname"><em>currentValue</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const bool &amp;&#160;</td>
          <td class="paramname"><em>lastValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write a bool delta. Same thing as just calling Write. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">currentValue</td><td>The current value to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lastValue</td><td>The last value to compare against </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="abd8613fe1f3d998a125fd2962c905e67"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteDelta </td>
          <td>(</td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>currentValue</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>lastValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write any integral type to a bitstream. </p>
<p>If the current value is different from the last value the current value will be written. Otherwise, a single bit will be written </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">currentValue</td><td>The current value to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lastValue</td><td>The last value to compare against </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a09461811793e5719e574d47bc513ac8a"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteDelta </td>
          <td>(</td>
          <td class="paramtype">const templateType &amp;&#160;</td>
          <td class="paramname"><em>currentValue</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>WriteDelta when you don't know what the last value is, or there is no last value. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">currentValue</td><td>The current value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="ad69701ef7d6efe0f69d61ff8287ccb78"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;&gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteDelta </td>
          <td>(</td>
          <td class="paramtype">const bool &amp;&#160;</td>
          <td class="paramname"><em>currentValue</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const bool &amp;&#160;</td>
          <td class="paramname"><em>lastValue</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write a bool delta. Same thing as just calling Write. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">currentValue</td><td>The current value to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">lastValue</td><td>The last value to compare against </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a8b37ff9ba34ce6f98c8521710ba51366"></a>
<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteFloat16 </td>
          <td>(</td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>floatMin</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">float&#160;</td>
          <td class="paramname"><em>floatMax</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write a float into 2 bytes, spanning the range between <em>floatMin</em> and <em>floatMax</em>. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>The float to write </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">floatMin</td><td>Predetermined minimum value of f </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">floatMax</td><td>Predetermined maximum value of f </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="acb96f0dce8b1a864799d02211cf34d8b"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteNormQuat </td>
          <td>(</td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>w</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write a normalized quaternion in 6 bytes + 4 bits instead of 16 bytes. Slightly lossy. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">w</td><td>w </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="aac37adc6bd171459103131d788fdebf7"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteNormVector </td>
          <td>(</td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write a normalized 3D vector, using (at most) 4 bytes + 3 bits instead of 12-24 bytes. </p>
<p>Will further compress y or z axis aligned vectors. Accurate to 1/32767.5. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="adb06e701aa336f41c314b88ae27c60bc"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteOrthMatrix </td>
          <td>(</td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m00</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m01</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m02</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m10</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m11</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m12</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m20</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m21</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>m22</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write an orthogonal matrix by creating a quaternion, and writing 3 components of the quaternion in 2 bytes each. </p>
<p>Use 6 bytes instead of 36 Lossy, although the result is renormalized </p>

</div>
</div>
<a class="anchor" id="a2aa6ce96e75cf8339c29d7101a5bdb3a"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WritePtr </td>
          <td>(</td>
          <td class="paramtype">templateType *&#160;</td>
          <td class="paramname"><em>inTemplateVar</em></td><td>)</td>
          <td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Write the dereferenced pointer to any integral type to a bitstream. </p>
<p>Undefine __BITSTREAM_NATIVE_END if you need endian swapping. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">inTemplateVar</td><td>The value to write </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a class="anchor" id="a0ffa67542bbe1e407a565652becb408f"></a>
<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;class templateType &gt; </div>
      <table class="memname">
        <tr>
          <td class="memname">void RakNet::BitStream::WriteVector </td>
          <td>(</td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>x</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>y</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">templateType&#160;</td>
          <td class="paramname"><em>z</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Write a vector, using 10 bytes instead of 12. </p>
<p>Loses accuracy to about 3/10ths and only saves 2 bytes, so only use if accuracy is not important. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramdir">[in]</td><td class="paramname">x</td><td>x </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">y</td><td>y </td></tr>
    <tr><td class="paramdir">[in]</td><td class="paramname">z</td><td>z </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<hr/>The documentation for this class was generated from the following file:<ul>
<li>D:/temp/RakNet_PC/Source/<a class="el" href="BitStream_8h.html">BitStream.h</a></li>
</ul>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated on Mon Jun 2 2014 20:10:28 for RakNet by &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/>
</a> 1.8.2
</small></address>
</body>
</html>