Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
337 kB · 10596 lines
at main
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174817581768177817881798180818181828183818481858186818781888189819081918192819381948195819681978198819982008201820282038204820582068207820882098210821182128213821482158216821782188219822082218222822382248225822682278228822982308231823282338234823582368237823882398240824182428243824482458246824782488249825082518252825382548255825682578258825982608261826282638264826582668267826882698270827182728273827482758276827782788279828082818282828382848285828682878288828982908291829282938294829582968297829882998300830183028303830483058306830783088309831083118312831383148315831683178318831983208321832283238324832583268327832883298330833183328333833483358336833783388339834083418342834383448345834683478348834983508351835283538354835583568357835883598360836183628363836483658366836783688369837083718372837383748375837683778378837983808381838283838384838583868387838883898390839183928393839483958396839783988399840084018402840384048405840684078408840984108411841284138414841584168417841884198420842184228423842484258426842784288429843084318432843384348435843684378438843984408441844284438444844584468447844884498450845184528453845484558456845784588459846084618462846384648465846684678468846984708471847284738474847584768477847884798480848184828483848484858486848784888489849084918492849384948495849684978498849985008501850285038504850585068507850885098510851185128513851485158516851785188519852085218522852385248525852685278528852985308531853285338534853585368537853885398540854185428543854485458546854785488549855085518552855385548555855685578558855985608561856285638564856585668567856885698570857185728573857485758576857785788579858085818582858385848585858685878588858985908591859285938594859585968597859885998600860186028603860486058606860786088609861086118612861386148615861686178618861986208621862286238624862586268627862886298630863186328633863486358636863786388639864086418642864386448645864686478648864986508651865286538654865586568657865886598660866186628663866486658666866786688669867086718672867386748675867686778678867986808681868286838684868586868687868886898690869186928693869486958696869786988699870087018702870387048705870687078708870987108711871287138714871587168717871887198720872187228723872487258726872787288729873087318732873387348735873687378738873987408741874287438744874587468747874887498750875187528753875487558756875787588759876087618762876387648765876687678768876987708771877287738774877587768777877887798780878187828783878487858786878787888789879087918792879387948795879687978798879988008801880288038804880588068807880888098810881188128813881488158816881788188819882088218822882388248825882688278828882988308831883288338834883588368837883888398840884188428843884488458846884788488849885088518852885388548855885688578858885988608861886288638864886588668867886888698870887188728873887488758876887788788879888088818882888388848885888688878888888988908891889288938894889588968897889888998900890189028903890489058906890789088909891089118912891389148915891689178918891989208921892289238924892589268927892889298930893189328933893489358936893789388939894089418942894389448945894689478948894989508951895289538954895589568957895889598960896189628963896489658966896789688969897089718972897389748975897689778978897989808981898289838984898589868987898889898990899189928993899489958996899789988999900090019002900390049005900690079008900990109011901290139014901590169017901890199020902190229023902490259026902790289029903090319032903390349035903690379038903990409041904290439044904590469047904890499050905190529053905490559056905790589059906090619062906390649065906690679068906990709071907290739074907590769077907890799080908190829083908490859086908790889089909090919092909390949095909690979098909991009101910291039104910591069107910891099110911191129113911491159116911791189119912091219122912391249125912691279128912991309131913291339134913591369137913891399140914191429143914491459146914791489149915091519152915391549155915691579158915991609161916291639164916591669167916891699170917191729173917491759176917791789179918091819182918391849185918691879188918991909191919291939194919591969197919891999200920192029203920492059206920792089209921092119212921392149215921692179218921992209221922292239224922592269227922892299230923192329233923492359236923792389239924092419242924392449245924692479248924992509251925292539254925592569257925892599260926192629263926492659266926792689269927092719272927392749275927692779278927992809281928292839284928592869287928892899290929192929293929492959296929792989299930093019302930393049305930693079308930993109311931293139314931593169317931893199320932193229323932493259326932793289329933093319332933393349335933693379338933993409341934293439344934593469347934893499350935193529353935493559356935793589359936093619362936393649365936693679368936993709371937293739374937593769377937893799380938193829383938493859386938793889389939093919392939393949395939693979398939994009401940294039404940594069407940894099410941194129413941494159416941794189419942094219422942394249425942694279428942994309431943294339434943594369437943894399440944194429443944494459446944794489449945094519452945394549455945694579458945994609461946294639464946594669467946894699470947194729473947494759476947794789479948094819482948394849485948694879488948994909491949294939494949594969497949894999500950195029503950495059506950795089509951095119512951395149515951695179518951995209521952295239524952595269527952895299530953195329533953495359536953795389539954095419542954395449545954695479548954995509551955295539554955595569557955895599560956195629563956495659566956795689569957095719572957395749575957695779578957995809581958295839584958595869587958895899590959195929593959495959596959795989599960096019602960396049605960696079608960996109611961296139614961596169617961896199620962196229623962496259626962796289629963096319632963396349635963696379638963996409641964296439644964596469647964896499650965196529653965496559656965796589659966096619662966396649665966696679668966996709671967296739674967596769677967896799680968196829683968496859686968796889689969096919692969396949695969696979698969997009701970297039704970597069707970897099710971197129713971497159716971797189719972097219722972397249725972697279728972997309731973297339734973597369737973897399740974197429743974497459746974797489749975097519752975397549755975697579758975997609761976297639764976597669767976897699770977197729773977497759776977797789779978097819782978397849785978697879788978997909791979297939794979597969797979897999800980198029803980498059806980798089809981098119812981398149815981698179818981998209821982298239824982598269827982898299830983198329833983498359836983798389839984098419842984398449845984698479848984998509851985298539854985598569857985898599860986198629863986498659866986798689869987098719872987398749875987698779878987998809881988298839884988598869887988898899890989198929893989498959896989798989899990099019902990399049905990699079908990999109911991299139914991599169917991899199920992199229923992499259926992799289929993099319932993399349935993699379938993999409941994299439944994599469947994899499950995199529953995499559956995799589959996099619962996399649965996699679968996999709971997299739974997599769977997899799980998199829983998499859986998799889989999099919992999399949995999699979998999910000100011000210003100041000510006100071000810009100101001110012100131001410015100161001710018100191002010021100221002310024100251002610027100281002910030100311003210033100341003510036100371003810039100401004110042100431004410045100461004710048100491005010051100521005310054100551005610057100581005910060100611006210063100641006510066100671006810069100701007110072100731007410075100761007710078100791008010081100821008310084100851008610087100881008910090100911009210093100941009510096100971009810099101001010110102101031010410105101061010710108101091011010111101121011310114101151011610117101181011910120101211012210123101241012510126101271012810129101301013110132101331013410135101361013710138101391014010141101421014310144101451014610147101481014910150101511015210153101541015510156101571015810159101601016110162101631016410165101661016710168101691017010171101721017310174101751017610177101781017910180101811018210183101841018510186101871018810189101901019110192101931019410195101961019710198101991020010201102021020310204102051020610207102081020910210102111021210213102141021510216102171021810219102201022110222102231022410225102261022710228102291023010231102321023310234102351023610237102381023910240102411024210243102441024510246102471024810249102501025110252102531025410255102561025710258102591026010261102621026310264102651026610267102681026910270102711027210273102741027510276102771027810279102801028110282102831028410285102861028710288102891029010291102921029310294102951029610297102981029910300103011030210303103041030510306103071030810309103101031110312103131031410315103161031710318103191032010321103221032310324103251032610327103281032910330103311033210333103341033510336103371033810339103401034110342103431034410345103461034710348103491035010351103521035310354103551035610357103581035910360103611036210363103641036510366103671036810369103701037110372103731037410375103761037710378103791038010381103821038310384103851038610387103881038910390103911039210393103941039510396103971039810399104001040110402104031040410405104061040710408104091041010411104121041310414104151041610417104181041910420104211042210423104241042510426104271042810429104301043110432104331043410435104361043710438104391044010441104421044310444104451044610447104481044910450104511045210453104541045510456104571045810459104601046110462104631046410465104661046710468104691047010471104721047310474104751047610477104781047910480104811048210483104841048510486104871048810489104901049110492104931049410495104961049710498104991050010501105021050310504105051050610507105081050910510105111051210513105141051510516105171051810519105201052110522105231052410525105261052710528105291053010531105321053310534105351053610537105381053910540105411054210543105441054510546105471054810549105501055110552105531055410555105561055710558105591056010561105621056310564105651056610567105681056910570105711057210573105741057510576105771057810579105801058110582105831058410585105861058710588105891059010591105921059310594105951059610597//-------------------------------------------------------------------------------------// DirectXMathVector.inl -- SIMD C++ Math library//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A// PARTICULAR PURPOSE.// // Copyright (c) Microsoft Corporation. All rights reserved.//-------------------------------------------------------------------------------------#ifdef _MSC_VER#pragma once#endif#if defined(_XM_NO_INTRINSICS_)#define XMISNAN(x) ((*(uint32_t*)&(x) & 0x7F800000) == 0x7F800000 && (*(uint32_t*)&(x) & 0x7FFFFF) != 0)#define XMISINF(x) ((*(uint32_t*)&(x) & 0x7FFFFFFF) == 0x7F800000)#endif/**************************************************************************** * * General Vector * ****************************************************************************///------------------------------------------------------------------------------// Assignment operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------// Return a vector with all elements equaling zeroinline XMVECTOR XMVectorZero(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = {0.0f,0.0f,0.0f,0.0f}; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32(0);#elif defined(_XM_SSE_INTRINSICS_) return _mm_setzero_ps();#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with four floating point valuesinline XMVECTOR XMVectorSet( float x, float y, float z, float w){#if defined(_XM_NO_INTRINSICS_) XMVECTORF32 vResult = {x,y,z,w}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 V0 = vcreate_f32(((uint64_t)*(const uint32_t *)&x) | ((uint64_t)(*(const uint32_t *)&y) << 32)); __n64 V1 = vcreate_f32(((uint64_t)*(const uint32_t *)&z) | ((uint64_t)(*(const uint32_t *)&w) << 32)); return vcombine_f32(V0, V1);#elif defined(_XM_SSE_INTRINSICS_) return _mm_set_ps( w, z, y, x );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with four integer valuesinline XMVECTOR XMVectorSetInt( uint32_t x, uint32_t y, uint32_t z, uint32_t w){#if defined(_XM_NO_INTRINSICS_) XMVECTORU32 vResult = {x,y,z,w}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 V0 = vcreate_u32(((uint64_t)x) | ((uint64_t)y << 32)); __n64 V1 = vcreate_u32(((uint64_t)z) | ((uint64_t)w << 32)); return vcombine_u32(V0, V1);#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_set_epi32( w, z, y, x ); return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with a replicated floating point valueinline XMVECTOR XMVectorReplicate( float Value){#if defined(_XM_NO_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) XMVECTORF32 vResult = {Value,Value,Value,Value}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_f32( Value );#elif defined(_XM_SSE_INTRINSICS_) return _mm_set_ps1( Value );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with a replicated floating point value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorReplicatePtr( const float *pValue){#if defined(_XM_NO_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) float Value = pValue[0]; XMVECTORF32 vResult = {Value,Value,Value,Value}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_dup_f32( pValue );#elif defined(_XM_SSE_INTRINSICS_) return _mm_load_ps1( pValue );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with a replicated integer valueinline XMVECTOR XMVectorReplicateInt( uint32_t Value){#if defined(_XM_NO_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) XMVECTORU32 vResult = {Value,Value,Value,Value}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32( Value );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_set1_epi32( Value ); return _mm_castsi128_ps(vTemp);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with a replicated integer value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorReplicateIntPtr( const uint32_t *pValue){#if defined(_XM_NO_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) uint32_t Value = pValue[0]; XMVECTORU32 vResult = {Value,Value,Value,Value}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_dup_u32(pValue);#elif defined(_XM_SSE_INTRINSICS_) return _mm_load_ps1(reinterpret_cast<const float *>(pValue));#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with all bits set (true mask)inline XMVECTOR XMVectorTrueInt(){#if defined(_XM_NO_INTRINSICS_) XMVECTORU32 vResult = {0xFFFFFFFFU,0xFFFFFFFFU,0xFFFFFFFFU,0xFFFFFFFFU}; return vResult.v;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_s32(-1);#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_set1_epi32(-1); return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Initialize a vector with all bits clear (false mask)inline XMVECTOR XMVectorFalseInt(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = {0.0f,0.0f,0.0f,0.0f}; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32(0);#elif defined(_XM_SSE_INTRINSICS_) return _mm_setzero_ps();#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Replicate the x component of the vectorinline XMVECTOR XMVectorSplatX( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_f32[0] = vResult.vector4_f32[1] = vResult.vector4_f32[2] = vResult.vector4_f32[3] = V.vector4_f32[0]; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_lane_f32( vget_low_f32( V ), 0 );#elif defined(_XM_SSE_INTRINSICS_) return XM_PERMUTE_PS( V, _MM_SHUFFLE(0, 0, 0, 0) );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Replicate the y component of the vectorinline XMVECTOR XMVectorSplatY( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_f32[0] = vResult.vector4_f32[1] = vResult.vector4_f32[2] = vResult.vector4_f32[3] = V.vector4_f32[1]; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_lane_f32( vget_low_f32( V ), 1 );#elif defined(_XM_SSE_INTRINSICS_) return XM_PERMUTE_PS( V, _MM_SHUFFLE(1, 1, 1, 1) );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Replicate the z component of the vectorinline XMVECTOR XMVectorSplatZ( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_f32[0] = vResult.vector4_f32[1] = vResult.vector4_f32[2] = vResult.vector4_f32[3] = V.vector4_f32[2]; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_lane_f32( vget_high_f32( V ), 0 );#elif defined(_XM_SSE_INTRINSICS_) return XM_PERMUTE_PS( V, _MM_SHUFFLE(2, 2, 2, 2) );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Replicate the w component of the vectorinline XMVECTOR XMVectorSplatW( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_f32[0] = vResult.vector4_f32[1] = vResult.vector4_f32[2] = vResult.vector4_f32[3] = V.vector4_f32[3]; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_lane_f32( vget_high_f32( V ), 1 );#elif defined(_XM_SSE_INTRINSICS_) return XM_PERMUTE_PS( V, _MM_SHUFFLE(3, 3, 3, 3) );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return a vector of 1.0f,1.0f,1.0f,1.0finline XMVECTOR XMVectorSplatOne(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_f32[0] = vResult.vector4_f32[1] = vResult.vector4_f32[2] = vResult.vector4_f32[3] = 1.0f; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_f32(1.0f);#elif defined(_XM_SSE_INTRINSICS_) return g_XMOne;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return a vector of INF,INF,INF,INFinline XMVECTOR XMVectorSplatInfinity(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_u32[0] = vResult.vector4_u32[1] = vResult.vector4_u32[2] = vResult.vector4_u32[3] = 0x7F800000; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32(0x7F800000);#elif defined(_XM_SSE_INTRINSICS_) return g_XMInfinity;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return a vector of Q_NAN,Q_NAN,Q_NAN,Q_NANinline XMVECTOR XMVectorSplatQNaN(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_u32[0] = vResult.vector4_u32[1] = vResult.vector4_u32[2] = vResult.vector4_u32[3] = 0x7FC00000; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32(0x7FC00000);#elif defined(_XM_SSE_INTRINSICS_) return g_XMQNaN;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return a vector of 1.192092896e-7f,1.192092896e-7f,1.192092896e-7f,1.192092896e-7finline XMVECTOR XMVectorSplatEpsilon(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_u32[0] = vResult.vector4_u32[1] = vResult.vector4_u32[2] = vResult.vector4_u32[3] = 0x34000000; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32(0x34000000);#elif defined(_XM_SSE_INTRINSICS_) return g_XMEpsilon;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return a vector of -0.0f (0x80000000),-0.0f,-0.0f,-0.0finline XMVECTOR XMVectorSplatSignMask(){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult; vResult.vector4_u32[0] = vResult.vector4_u32[1] = vResult.vector4_u32[2] = vResult.vector4_u32[3] = 0x80000000U; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vdupq_n_u32(0x80000000U);#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_set1_epi32( 0x80000000 ); return reinterpret_cast<__m128*>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return a floating point value via an index. This is not a recommended// function to use due to performance loss.inline float XMVectorGetByIndex(FXMVECTOR V, size_t i){ assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) return V.vector4_f32[i];#elif defined(_XM_ARM_NEON_INTRINSICS_) return V.n128_f32[i];#elif defined(_XM_SSE_INTRINSICS_) return V.m128_f32[i];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return the X component in an FPU register. inline float XMVectorGetX(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_f32[0];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_f32(V, 0);#elif defined(_XM_SSE_INTRINSICS_) return _mm_cvtss_f32(V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Return the Y component in an FPU register. inline float XMVectorGetY(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_f32[1];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_f32(V, 1);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); return _mm_cvtss_f32(vTemp);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Return the Z component in an FPU register. inline float XMVectorGetZ(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_f32[2];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_f32(V, 2);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2)); return _mm_cvtss_f32(vTemp);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Return the W component in an FPU register. inline float XMVectorGetW(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_f32[3];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_f32(V, 3);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,3,3,3)); return _mm_cvtss_f32(vTemp);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Store a component indexed by i into a 32 bit float location in memory._Use_decl_annotations_inline void XMVectorGetByIndexPtr(float *f, FXMVECTOR V, size_t i){ assert( f != NULL ); assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) *f = V.vector4_f32[i];#elif defined(_XM_ARM_NEON_INTRINSICS_) *f = V.n128_f32[i];#elif defined(_XM_SSE_INTRINSICS_) *f = V.m128_f32[i];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Store the X component into a 32 bit float location in memory._Use_decl_annotations_inline void XMVectorGetXPtr(float *x, FXMVECTOR V){ assert( x != NULL);#if defined(_XM_NO_INTRINSICS_) *x = V.vector4_f32[0];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_f32(x,V,0);#elif defined(_XM_SSE_INTRINSICS_) _mm_store_ss(x,V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Store the Y component into a 32 bit float location in memory._Use_decl_annotations_inline void XMVectorGetYPtr(float *y, FXMVECTOR V){ assert( y != NULL );#if defined(_XM_NO_INTRINSICS_) *y = V.vector4_f32[1];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_f32(y,V,1);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); _mm_store_ss(y,vResult);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Store the Z component into a 32 bit float location in memory._Use_decl_annotations_inline void XMVectorGetZPtr(float *z, FXMVECTOR V){ assert( z != NULL );#if defined(_XM_NO_INTRINSICS_) *z = V.vector4_f32[2];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_f32(z,V,2);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2)); _mm_store_ss(z,vResult);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Store the W component into a 32 bit float location in memory._Use_decl_annotations_inline void XMVectorGetWPtr(float *w, FXMVECTOR V){ assert( w != NULL );#if defined(_XM_NO_INTRINSICS_) *w = V.vector4_f32[3];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_f32(w,V,3);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,3,3,3)); _mm_store_ss(w,vResult);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return an integer value via an index. This is not a recommended// function to use due to performance loss.inline uint32_t XMVectorGetIntByIndex(FXMVECTOR V, size_t i){ assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) return V.vector4_u32[i];#elif defined(_XM_ARM_NEON_INTRINSICS_) return V.n128_u32[i];#elif defined(_XM_SSE_INTRINSICS_) return V.m128_u32[i];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return the X component in an integer register. inline uint32_t XMVectorGetIntX(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_u32[0];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_u32(V, 0);#elif defined(_XM_SSE_INTRINSICS_) return static_cast<uint32_t>(_mm_cvtsi128_si32(_mm_castps_si128(V)));#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Return the Y component in an integer register. inline uint32_t XMVectorGetIntY(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_u32[1];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_u32(V, 1);#elif defined(_XM_SSE_INTRINSICS_) __m128i vResulti = _mm_shuffle_epi32(_mm_castps_si128(V),_MM_SHUFFLE(1,1,1,1)); return static_cast<uint32_t>(_mm_cvtsi128_si32(vResulti));#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Return the Z component in an integer register. inline uint32_t XMVectorGetIntZ(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_u32[2];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_u32(V, 2);#elif defined(_XM_SSE_INTRINSICS_) __m128i vResulti = _mm_shuffle_epi32(_mm_castps_si128(V),_MM_SHUFFLE(2,2,2,2)); return static_cast<uint32_t>(_mm_cvtsi128_si32(vResulti));#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Return the W component in an integer register. inline uint32_t XMVectorGetIntW(FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return V.vector4_u32[3];#elif defined(_XM_ARM_NEON_INTRINSICS_) return vgetq_lane_u32(V, 3);#elif defined(_XM_SSE_INTRINSICS_) __m128i vResulti = _mm_shuffle_epi32(_mm_castps_si128(V),_MM_SHUFFLE(3,3,3,3)); return static_cast<uint32_t>(_mm_cvtsi128_si32(vResulti));#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Store a component indexed by i into a 32 bit integer location in memory._Use_decl_annotations_inline void XMVectorGetIntByIndexPtr(uint32_t *x, FXMVECTOR V, size_t i){ assert( x != NULL ); assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) *x = V.vector4_u32[i];#elif defined(_XM_ARM_NEON_INTRINSICS_) *x = V.n128_u32[i];#elif defined(_XM_SSE_INTRINSICS_) *x = V.m128_u32[i];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Store the X component into a 32 bit integer location in memory._Use_decl_annotations_inline void XMVectorGetIntXPtr(uint32_t *x, FXMVECTOR V){ assert( x != NULL );#if defined(_XM_NO_INTRINSICS_) *x = V.vector4_u32[0];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_u32(x,V,0);#elif defined(_XM_SSE_INTRINSICS_) _mm_store_ss(reinterpret_cast<float *>(x),V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Store the Y component into a 32 bit integer location in memory._Use_decl_annotations_inline void XMVectorGetIntYPtr(uint32_t *y, FXMVECTOR V){ assert( y != NULL );#if defined(_XM_NO_INTRINSICS_) *y = V.vector4_u32[1];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_u32(y,V,1);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); _mm_store_ss(reinterpret_cast<float *>(y),vResult);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Store the Z component into a 32 bit integer locaCantion in memory._Use_decl_annotations_inline void XMVectorGetIntZPtr(uint32_t *z, FXMVECTOR V){ assert( z != NULL );#if defined(_XM_NO_INTRINSICS_) *z = V.vector4_u32[2];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_u32(z,V,2);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2)); _mm_store_ss(reinterpret_cast<float *>(z),vResult);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Store the W component into a 32 bit integer location in memory._Use_decl_annotations_inline void XMVectorGetIntWPtr(uint32_t *w, FXMVECTOR V){ assert( w != NULL );#if defined(_XM_NO_INTRINSICS_) *w = V.vector4_u32[3];#elif defined(_XM_ARM_NEON_INTRINSICS_) vst1q_lane_u32(w,V,3);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,3,3,3)); _mm_store_ss(reinterpret_cast<float *>(w),vResult);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Set a single indexed floating point componentinline XMVECTOR XMVectorSetByIndex(FXMVECTOR V, float f, size_t i){ assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U = V; U.vector4_f32[i] = f; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR U = V; U.n128_f32[i] = f; return U;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR U = V; U.m128_f32[i] = f; return U;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets the X component of a vector to a passed floating point valueinline XMVECTOR XMVectorSetX(FXMVECTOR V, float x){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = x; U.vector4_f32[1] = V.vector4_f32[1]; U.vector4_f32[2] = V.vector4_f32[2]; U.vector4_f32[3] = V.vector4_f32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_f32(x,V,0);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_set_ss(x); vResult = _mm_move_ss(V,vResult); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Y component of a vector to a passed floating point valueinline XMVECTOR XMVectorSetY(FXMVECTOR V, float y){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = V.vector4_f32[0]; U.vector4_f32[1] = y; U.vector4_f32[2] = V.vector4_f32[2]; U.vector4_f32[3] = V.vector4_f32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_f32(y,V,1);#elif defined(_XM_SSE_INTRINSICS_) // Swap y and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,2,0,1)); // Convert input to vector XMVECTOR vTemp = _mm_set_ss(y); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap y and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,2,0,1)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Z component of a vector to a passed floating point valueinline XMVECTOR XMVectorSetZ(FXMVECTOR V, float z){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = V.vector4_f32[0]; U.vector4_f32[1] = V.vector4_f32[1]; U.vector4_f32[2] = z; U.vector4_f32[3] = V.vector4_f32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_f32(z,V,2);#elif defined(_XM_SSE_INTRINSICS_) // Swap z and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,0,1,2)); // Convert input to vector XMVECTOR vTemp = _mm_set_ss(z); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap z and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,0,1,2)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the W component of a vector to a passed floating point valueinline XMVECTOR XMVectorSetW(FXMVECTOR V, float w){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = V.vector4_f32[0]; U.vector4_f32[1] = V.vector4_f32[1]; U.vector4_f32[2] = V.vector4_f32[2]; U.vector4_f32[3] = w; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_f32(w,V,3);#elif defined(_XM_SSE_INTRINSICS_) // Swap w and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,2,1,3)); // Convert input to vector XMVECTOR vTemp = _mm_set_ss(w); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap w and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(0,2,1,3)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets a component of a vector to a floating point value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetByIndexPtr(FXMVECTOR V, const float *f, size_t i){ assert( f != NULL ); assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U = V; U.vector4_f32[i] = *f; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR U = V; U.n128_f32[i] = *f; return U;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR U = V; U.m128_f32[i] = *f; return U;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets the X component of a vector to a floating point value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetXPtr(FXMVECTOR V, const float *x){ assert( x != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = *x; U.vector4_f32[1] = V.vector4_f32[1]; U.vector4_f32[2] = V.vector4_f32[2]; U.vector4_f32[3] = V.vector4_f32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_f32(x,V,0);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_load_ss(x); vResult = _mm_move_ss(V,vResult); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Y component of a vector to a floating point value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetYPtr(FXMVECTOR V, const float *y){ assert( y != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = V.vector4_f32[0]; U.vector4_f32[1] = *y; U.vector4_f32[2] = V.vector4_f32[2]; U.vector4_f32[3] = V.vector4_f32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_f32(y,V,1);#elif defined(_XM_SSE_INTRINSICS_) // Swap y and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,2,0,1)); // Convert input to vector XMVECTOR vTemp = _mm_load_ss(y); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap y and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,2,0,1)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Z component of a vector to a floating point value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetZPtr(FXMVECTOR V, const float *z){ assert( z != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = V.vector4_f32[0]; U.vector4_f32[1] = V.vector4_f32[1]; U.vector4_f32[2] = *z; U.vector4_f32[3] = V.vector4_f32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_f32(z,V,2);#elif defined(_XM_SSE_INTRINSICS_) // Swap z and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,0,1,2)); // Convert input to vector XMVECTOR vTemp = _mm_load_ss(z); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap z and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,0,1,2)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the W component of a vector to a floating point value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetWPtr(FXMVECTOR V, const float *w){ assert( w != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_f32[0] = V.vector4_f32[0]; U.vector4_f32[1] = V.vector4_f32[1]; U.vector4_f32[2] = V.vector4_f32[2]; U.vector4_f32[3] = *w; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_f32(w,V,3);#elif defined(_XM_SSE_INTRINSICS_) // Swap w and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,2,1,3)); // Convert input to vector XMVECTOR vTemp = _mm_load_ss(w); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap w and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(0,2,1,3)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets a component of a vector to an integer passed by valueinline XMVECTOR XMVectorSetIntByIndex(FXMVECTOR V, uint32_t x, size_t i){ assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U = V; U.vector4_u32[i] = x; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTORU32 tmp; tmp.v = V; tmp.u[i] = x; return tmp;#elif defined(_XM_SSE_INTRINSICS_) XMVECTORU32 tmp; tmp.v = V; tmp.u[i] = x; return tmp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets the X component of a vector to an integer passed by valueinline XMVECTOR XMVectorSetIntX(FXMVECTOR V, uint32_t x){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = x; U.vector4_u32[1] = V.vector4_u32[1]; U.vector4_u32[2] = V.vector4_u32[2]; U.vector4_u32[3] = V.vector4_u32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_u32(x,V,0);#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cvtsi32_si128(x); XMVECTOR vResult = _mm_move_ss(V,_mm_castsi128_ps(vTemp)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Y component of a vector to an integer passed by valueinline XMVECTOR XMVectorSetIntY(FXMVECTOR V, uint32_t y){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = V.vector4_u32[0]; U.vector4_u32[1] = y; U.vector4_u32[2] = V.vector4_u32[2]; U.vector4_u32[3] = V.vector4_u32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_u32(y,V,1);#elif defined(_XM_SSE_INTRINSICS_) // Swap y and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,2,0,1)); // Convert input to vector __m128i vTemp = _mm_cvtsi32_si128(y); // Replace the x component vResult = _mm_move_ss(vResult,_mm_castsi128_ps(vTemp)); // Swap y and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,2,0,1)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Z component of a vector to an integer passed by valueinline XMVECTOR XMVectorSetIntZ(FXMVECTOR V, uint32_t z){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = V.vector4_u32[0]; U.vector4_u32[1] = V.vector4_u32[1]; U.vector4_u32[2] = z; U.vector4_u32[3] = V.vector4_u32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_u32(z,V,2);#elif defined(_XM_SSE_INTRINSICS_) // Swap z and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,0,1,2)); // Convert input to vector __m128i vTemp = _mm_cvtsi32_si128(z); // Replace the x component vResult = _mm_move_ss(vResult,_mm_castsi128_ps(vTemp)); // Swap z and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,0,1,2)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the W component of a vector to an integer passed by valueinline XMVECTOR XMVectorSetIntW(FXMVECTOR V, uint32_t w){#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = V.vector4_u32[0]; U.vector4_u32[1] = V.vector4_u32[1]; U.vector4_u32[2] = V.vector4_u32[2]; U.vector4_u32[3] = w; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsetq_lane_u32(w,V,3);#elif defined(_XM_SSE_INTRINSICS_) // Swap w and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,2,1,3)); // Convert input to vector __m128i vTemp = _mm_cvtsi32_si128(w); // Replace the x component vResult = _mm_move_ss(vResult,_mm_castsi128_ps(vTemp)); // Swap w and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(0,2,1,3)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets a component of a vector to an integer value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetIntByIndexPtr(FXMVECTOR V, const uint32_t *x, size_t i){ assert( x != NULL ); assert( i < 4 ); _Analysis_assume_( i < 4 );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U = V; U.vector4_u32[i] = *x; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTORU32 tmp; tmp.v = V; tmp.u[i] = *x; return tmp;#elif defined(_XM_SSE_INTRINSICS_) XMVECTORU32 tmp; tmp.v = V; tmp.u[i] = *x; return tmp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Sets the X component of a vector to an integer value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetIntXPtr(FXMVECTOR V, const uint32_t *x){ assert( x != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = *x; U.vector4_u32[1] = V.vector4_u32[1]; U.vector4_u32[2] = V.vector4_u32[2]; U.vector4_u32[3] = V.vector4_u32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_u32(x,V,0);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float *>(x)); XMVECTOR vResult = _mm_move_ss(V,vTemp); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Y component of a vector to an integer value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetIntYPtr(FXMVECTOR V, const uint32_t *y){ assert( y != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = V.vector4_u32[0]; U.vector4_u32[1] = *y; U.vector4_u32[2] = V.vector4_u32[2]; U.vector4_u32[3] = V.vector4_u32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_u32(y,V,1);#elif defined(_XM_SSE_INTRINSICS_) // Swap y and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,2,0,1)); // Convert input to vector XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float *>(y)); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap y and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,2,0,1)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the Z component of a vector to an integer value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetIntZPtr(FXMVECTOR V, const uint32_t *z){ assert( z != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = V.vector4_u32[0]; U.vector4_u32[1] = V.vector4_u32[1]; U.vector4_u32[2] = *z; U.vector4_u32[3] = V.vector4_u32[3]; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_u32(z,V,2);#elif defined(_XM_SSE_INTRINSICS_) // Swap z and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,0,1,2)); // Convert input to vector XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float *>(z)); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap z and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,0,1,2)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}// Sets the W component of a vector to an integer value passed by pointer_Use_decl_annotations_inline XMVECTOR XMVectorSetIntWPtr(FXMVECTOR V, const uint32_t *w){ assert( w != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR U; U.vector4_u32[0] = V.vector4_u32[0]; U.vector4_u32[1] = V.vector4_u32[1]; U.vector4_u32[2] = V.vector4_u32[2]; U.vector4_u32[3] = *w; return U;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vld1q_lane_u32(w,V,3);#elif defined(_XM_SSE_INTRINSICS_) // Swap w and x XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,2,1,3)); // Convert input to vector XMVECTOR vTemp = _mm_load_ss(reinterpret_cast<const float *>(w)); // Replace the x component vResult = _mm_move_ss(vResult,vTemp); // Swap w and x again vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(0,2,1,3)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSwizzle( FXMVECTOR V, uint32_t E0, uint32_t E1, uint32_t E2, uint32_t E3){ assert( (E0 < 4) && (E1 < 4) && (E2 < 4) && (E3 < 4) ); _Analysis_assume_( (E0 < 4) && (E1 < 4) && (E2 < 4) && (E3 < 4) );#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result = { V.vector4_f32[E0], V.vector4_f32[E1], V.vector4_f32[E2], V.vector4_f32[E3] }; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const uint32_t ControlElement[ 4 ] = {#ifdef _XM_LITTLEENDIAN_ 0x03020100, // XM_SWIZZLE_X 0x07060504, // XM_SWIZZLE_Y 0x0B0A0908, // XM_SWIZZLE_Z 0x0F0E0D0C, // XM_SWIZZLE_W#else 0x00010203, // XM_SWIZZLE_X 0x04050607, // XM_SWIZZLE_Y 0x08090A0B, // XM_SWIZZLE_Z 0x0C0D0E0F, // XM_SWIZZLE_W#endif }; int8x8x2_t tbl; tbl.val[0] = vget_low_f32(V); tbl.val[1] = vget_high_f32(V); __n64 idx = vcreate_u32( ((uint64_t)ControlElement[E0]) | (((uint64_t)ControlElement[E1]) << 32) ); const __n64 rL = vtbl2_u8( tbl, idx ); idx = vcreate_u32( ((uint64_t)ControlElement[E2]) | (((uint64_t)ControlElement[E3]) << 32) ); const __n64 rH = vtbl2_u8( tbl, idx ); return vcombine_f32( rL, rH );#elif defined(_XM_VMX128_INTRINSICS_)#else const uint32_t *aPtr = (const uint32_t* )(&V); XMVECTOR Result; uint32_t *pWork = (uint32_t*)(&Result); pWork[0] = aPtr[E0]; pWork[1] = aPtr[E1]; pWork[2] = aPtr[E2]; pWork[3] = aPtr[E3]; return Result;#endif}//------------------------------------------------------------------------------inline XMVECTOR XMVectorPermute( FXMVECTOR V1, FXMVECTOR V2, uint32_t PermuteX, uint32_t PermuteY, uint32_t PermuteZ, uint32_t PermuteW){ assert( PermuteX <= 7 && PermuteY <= 7 && PermuteZ <= 7 && PermuteW <= 7 ); _Analysis_assume_( PermuteX <= 7 && PermuteY <= 7 && PermuteZ <= 7 && PermuteW <= 7 );#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_) static const uint32_t ControlElement[ 8 ] = {#ifdef _XM_LITTLEENDIAN_ 0x03020100, // XM_PERMUTE_0X 0x07060504, // XM_PERMUTE_0Y 0x0B0A0908, // XM_PERMUTE_0Z 0x0F0E0D0C, // XM_PERMUTE_0W 0x13121110, // XM_PERMUTE_1X 0x17161514, // XM_PERMUTE_1Y 0x1B1A1918, // XM_PERMUTE_1Z 0x1F1E1D1C, // XM_PERMUTE_1W#else 0x00010203, // XM_PERMUTE_0X 0x04050607, // XM_PERMUTE_0Y 0x08090A0B, // XM_PERMUTE_0Z 0x0C0D0E0F, // XM_PERMUTE_0W 0x10111213, // XM_PERMUTE_1X 0x14151617, // XM_PERMUTE_1Y 0x18191A1B, // XM_PERMUTE_1Z 0x1C1D1E1F, // XM_PERMUTE_1W#endif }; int8x8x4_t tbl; tbl.val[0] = vget_low_f32(V1); tbl.val[1] = vget_high_f32(V1); tbl.val[2] = vget_low_f32(V2); tbl.val[3] = vget_high_f32(V2); __n64 idx = vcreate_u32( ((uint64_t)ControlElement[PermuteX]) | (((uint64_t)ControlElement[PermuteY]) << 32) ); const __n64 rL = vtbl4_u8( tbl, idx ); idx = vcreate_u32( ((uint64_t)ControlElement[PermuteZ]) | (((uint64_t)ControlElement[PermuteW]) << 32) ); const __n64 rH = vtbl4_u8( tbl, idx ); return vcombine_f32( rL, rH );#elif defined(_XM_VMX128_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)#else const uint32_t *aPtr[2]; aPtr[0] = (const uint32_t* )(&V1); aPtr[1] = (const uint32_t* )(&V2); XMVECTOR Result; uint32_t *pWork = (uint32_t*)(&Result); const uint32_t i0 = PermuteX & 3; const uint32_t vi0 = PermuteX >> 2; pWork[0] = aPtr[vi0][i0]; const uint32_t i1 = PermuteY & 3; const uint32_t vi1 = PermuteY >> 2; pWork[1] = aPtr[vi1][i1]; const uint32_t i2 = PermuteZ & 3; const uint32_t vi2 = PermuteZ >> 2; pWork[2] = aPtr[vi2][i2]; const uint32_t i3 = PermuteW & 3; const uint32_t vi3 = PermuteW >> 2; pWork[3] = aPtr[vi3][i3]; return Result;#endif}//------------------------------------------------------------------------------// Define a control vector to be used in XMVectorSelect // operations. The four integers specified in XMVectorSelectControl// serve as indices to select between components in two vectors.// The first index controls selection for the first component of // the vectors involved in a select operation, the second index // controls selection for the second component etc. A value of// zero for an index causes the corresponding component from the first // vector to be selected whereas a one causes the component from the// second vector to be selected instead.inline XMVECTOR XMVectorSelectControl( uint32_t VectorIndex0, uint32_t VectorIndex1, uint32_t VectorIndex2, uint32_t VectorIndex3){#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_) // x=Index0,y=Index1,z=Index2,w=Index3 __m128i vTemp = _mm_set_epi32(VectorIndex3,VectorIndex2,VectorIndex1,VectorIndex0); // Any non-zero entries become 0xFFFFFFFF else 0 vTemp = _mm_cmpgt_epi32(vTemp,g_XMZero); return reinterpret_cast<__m128 *>(&vTemp)[0];#elif defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_) __n64 V0 = vcreate_s32(((uint64_t)VectorIndex0) | ((uint64_t)VectorIndex1 << 32)); __n64 V1 = vcreate_s32(((uint64_t)VectorIndex2) | ((uint64_t)VectorIndex3 << 32)); __n128 vTemp = vcombine_s32(V0, V1); // Any non-zero entries become 0xFFFFFFFF else 0 return vcgtq_s32(vTemp,g_XMZero);#else XMVECTOR ControlVector; const uint32_t ControlElement[] = { XM_SELECT_0, XM_SELECT_1 }; assert(VectorIndex0 < 2); assert(VectorIndex1 < 2); assert(VectorIndex2 < 2); assert(VectorIndex3 < 2); _Analysis_assume_(VectorIndex0 < 2); _Analysis_assume_(VectorIndex1 < 2); _Analysis_assume_(VectorIndex2 < 2); _Analysis_assume_(VectorIndex3 < 2); ControlVector.vector4_u32[0] = ControlElement[VectorIndex0]; ControlVector.vector4_u32[1] = ControlElement[VectorIndex1]; ControlVector.vector4_u32[2] = ControlElement[VectorIndex2]; ControlVector.vector4_u32[3] = ControlElement[VectorIndex3]; return ControlVector;#endif}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSelect( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Control){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = (V1.vector4_u32[0] & ~Control.vector4_u32[0]) | (V2.vector4_u32[0] & Control.vector4_u32[0]); Result.vector4_u32[1] = (V1.vector4_u32[1] & ~Control.vector4_u32[1]) | (V2.vector4_u32[1] & Control.vector4_u32[1]); Result.vector4_u32[2] = (V1.vector4_u32[2] & ~Control.vector4_u32[2]) | (V2.vector4_u32[2] & Control.vector4_u32[2]); Result.vector4_u32[3] = (V1.vector4_u32[3] & ~Control.vector4_u32[3]) | (V2.vector4_u32[3] & Control.vector4_u32[3]); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vbslq_f32( Control, V2, V1 );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp1 = _mm_andnot_ps(Control,V1); XMVECTOR vTemp2 = _mm_and_ps(V2,Control); return _mm_or_ps(vTemp1,vTemp2);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorMergeXY( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = V1.vector4_u32[0]; Result.vector4_u32[1] = V2.vector4_u32[0]; Result.vector4_u32[2] = V1.vector4_u32[1]; Result.vector4_u32[3] = V2.vector4_u32[1]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vzipq_f32( V1, V2 ).val[0];#elif defined(_XM_SSE_INTRINSICS_) return _mm_unpacklo_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorMergeZW( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = V1.vector4_u32[2]; Result.vector4_u32[1] = V2.vector4_u32[2]; Result.vector4_u32[2] = V1.vector4_u32[3]; Result.vector4_u32[3] = V2.vector4_u32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vzipq_f32( V1, V2 ).val[1];#elif defined(_XM_SSE_INTRINSICS_) return _mm_unpackhi_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorShiftLeft(FXMVECTOR V1, FXMVECTOR V2, uint32_t Elements){ assert( Elements < 4 ); _Analysis_assume_( Elements < 4 ); return XMVectorPermute(V1, V2, Elements, ((Elements) + 1), ((Elements) + 2), ((Elements) + 3));}//------------------------------------------------------------------------------inline XMVECTOR XMVectorRotateLeft(FXMVECTOR V, uint32_t Elements){ assert( Elements < 4 ); _Analysis_assume_( Elements < 4 ); return XMVectorSwizzle( V, Elements & 3, (Elements + 1) & 3, (Elements + 2) & 3, (Elements + 3) & 3 );}//------------------------------------------------------------------------------inline XMVECTOR XMVectorRotateRight(FXMVECTOR V, uint32_t Elements){ assert( Elements < 4 ); _Analysis_assume_( Elements < 4 ); return XMVectorSwizzle( V, (4 - (Elements)) & 3, (5 - (Elements)) & 3, (6 - (Elements)) & 3, (7 - (Elements)) & 3 );}//------------------------------------------------------------------------------inline XMVECTOR XMVectorInsert(FXMVECTOR VD, FXMVECTOR VS, uint32_t VSLeftRotateElements, uint32_t Select0, uint32_t Select1, uint32_t Select2, uint32_t Select3){ XMVECTOR Control = XMVectorSelectControl(Select0&1, Select1&1, Select2&1, Select3&1); return XMVectorSelect( VD, XMVectorRotateLeft(VS, VSLeftRotateElements), Control );}//------------------------------------------------------------------------------// Comparison operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline XMVECTOR XMVectorEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_f32[0] == V2.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_f32[1] == V2.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_f32[2] == V2.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_f32[3] == V2.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vceqq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_cmpeq_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMVECTOR XMVectorEqualR( uint32_t* pCR, FXMVECTOR V1, FXMVECTOR V2){ assert( pCR != NULL );#if defined(_XM_NO_INTRINSICS_) uint32_t ux = (V1.vector4_f32[0] == V2.vector4_f32[0]) ? 0xFFFFFFFFU : 0; uint32_t uy = (V1.vector4_f32[1] == V2.vector4_f32[1]) ? 0xFFFFFFFFU : 0; uint32_t uz = (V1.vector4_f32[2] == V2.vector4_f32[2]) ? 0xFFFFFFFFU : 0; uint32_t uw = (V1.vector4_f32[3] == V2.vector4_f32[3]) ? 0xFFFFFFFFU : 0; uint32_t CR = 0; if (ux&uy&uz&uw) { // All elements are greater CR = XM_CRMASK_CR6TRUE; } else if (!(ux|uy|uz|uw)) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; XMVECTOR Control; Control.vector4_u32[0] = ux; Control.vector4_u32[1] = uy; Control.vector4_u32[2] = uz; Control.vector4_u32[3] = uw; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { // All elements are equal CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { // All elements are not equal CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vResult;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2); uint32_t CR = 0; int iTest = _mm_movemask_ps(vTemp); if (iTest==0xf) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vTemp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Treat the components of the vectors as unsigned integers and// compare individual bits between the two. This is useful for// comparing control vectors and result vectors returned from// other comparison operations.inline XMVECTOR XMVectorEqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_u32[0] == V2.vector4_u32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_u32[1] == V2.vector4_u32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_u32[2] == V2.vector4_u32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_u32[3] == V2.vector4_u32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vceqq_u32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_cmpeq_epi32( _mm_castps_si128(V1),_mm_castps_si128(V2) ); return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMVECTOR XMVectorEqualIntR( uint32_t* pCR, FXMVECTOR V1, FXMVECTOR V2){ assert( pCR != NULL );#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control = XMVectorEqualInt(V1, V2); *pCR = 0; if (XMVector4EqualInt(Control, XMVectorTrueInt())) { // All elements are equal *pCR |= XM_CRMASK_CR6TRUE; } else if (XMVector4EqualInt(Control, XMVectorFalseInt())) { // All elements are not equal *pCR |= XM_CRMASK_CR6FALSE; } return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { // All elements are equal CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { // All elements are not equal CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vResult;#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_cmpeq_epi32( _mm_castps_si128(V1),_mm_castps_si128(V2) ); int iTemp = _mm_movemask_ps(reinterpret_cast<const __m128*>(&V)[0]); uint32_t CR = 0; if (iTemp==0x0F) { CR = XM_CRMASK_CR6TRUE; } else if (!iTemp) { CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorNearEqual( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon){#if defined(_XM_NO_INTRINSICS_) float fDeltax = V1.vector4_f32[0]-V2.vector4_f32[0]; float fDeltay = V1.vector4_f32[1]-V2.vector4_f32[1]; float fDeltaz = V1.vector4_f32[2]-V2.vector4_f32[2]; float fDeltaw = V1.vector4_f32[3]-V2.vector4_f32[3]; fDeltax = fabsf(fDeltax); fDeltay = fabsf(fDeltay); fDeltaz = fabsf(fDeltaz); fDeltaw = fabsf(fDeltaw); XMVECTOR Control; Control.vector4_u32[0] = (fDeltax <= Epsilon.vector4_f32[0]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[1] = (fDeltay <= Epsilon.vector4_f32[1]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[2] = (fDeltaz <= Epsilon.vector4_f32[2]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[3] = (fDeltaw <= Epsilon.vector4_f32[3]) ? 0xFFFFFFFFU : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR vDelta = vsubq_f32(V1,V2); return vacleq_f32( vDelta, Epsilon );#elif defined(_XM_SSE_INTRINSICS_) // Get the difference XMVECTOR vDelta = _mm_sub_ps(V1,V2); // Get the absolute value of the difference XMVECTOR vTemp = _mm_setzero_ps(); vTemp = _mm_sub_ps(vTemp,vDelta); vTemp = _mm_max_ps(vTemp,vDelta); vTemp = _mm_cmple_ps(vTemp,Epsilon); return vTemp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorNotEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_f32[0] != V2.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_f32[1] != V2.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_f32[2] != V2.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_f32[3] != V2.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmvnq_u32(vceqq_f32(V1, V2));#elif defined(_XM_SSE_INTRINSICS_) return _mm_cmpneq_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorNotEqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_u32[0] != V2.vector4_u32[0]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[1] = (V1.vector4_u32[1] != V2.vector4_u32[1]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[2] = (V1.vector4_u32[2] != V2.vector4_u32[2]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[3] = (V1.vector4_u32[3] != V2.vector4_u32[3]) ? 0xFFFFFFFFU : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmvnq_u32(vceqq_u32(V1, V2));#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_cmpeq_epi32( _mm_castps_si128(V1),_mm_castps_si128(V2) ); return _mm_xor_ps(reinterpret_cast<__m128 *>(&V)[0],g_XMNegOneMask);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorGreater( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_f32[0] > V2.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_f32[1] > V2.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_f32[2] > V2.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_f32[3] > V2.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vcgtq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_cmpgt_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMVECTOR XMVectorGreaterR( uint32_t* pCR, FXMVECTOR V1, FXMVECTOR V2){ assert( pCR != NULL );#if defined(_XM_NO_INTRINSICS_) uint32_t ux = (V1.vector4_f32[0] > V2.vector4_f32[0]) ? 0xFFFFFFFFU : 0; uint32_t uy = (V1.vector4_f32[1] > V2.vector4_f32[1]) ? 0xFFFFFFFFU : 0; uint32_t uz = (V1.vector4_f32[2] > V2.vector4_f32[2]) ? 0xFFFFFFFFU : 0; uint32_t uw = (V1.vector4_f32[3] > V2.vector4_f32[3]) ? 0xFFFFFFFFU : 0; uint32_t CR = 0; if (ux&uy&uz&uw) { // All elements are greater CR = XM_CRMASK_CR6TRUE; } else if (!(ux|uy|uz|uw)) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; XMVECTOR Control; Control.vector4_u32[0] = ux; Control.vector4_u32[1] = uy; Control.vector4_u32[2] = uz; Control.vector4_u32[3] = uw; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgtq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { // All elements are greater CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vResult;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2); uint32_t CR = 0; int iTest = _mm_movemask_ps(vTemp); if (iTest==0xf) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vTemp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorGreaterOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_f32[0] >= V2.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_f32[1] >= V2.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_f32[2] >= V2.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_f32[3] >= V2.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vcgeq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_cmpge_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMVECTOR XMVectorGreaterOrEqualR( uint32_t* pCR, FXMVECTOR V1, FXMVECTOR V2){ assert( pCR != NULL );#if defined(_XM_NO_INTRINSICS_) uint32_t ux = (V1.vector4_f32[0] >= V2.vector4_f32[0]) ? 0xFFFFFFFFU : 0; uint32_t uy = (V1.vector4_f32[1] >= V2.vector4_f32[1]) ? 0xFFFFFFFFU : 0; uint32_t uz = (V1.vector4_f32[2] >= V2.vector4_f32[2]) ? 0xFFFFFFFFU : 0; uint32_t uw = (V1.vector4_f32[3] >= V2.vector4_f32[3]) ? 0xFFFFFFFFU : 0; uint32_t CR = 0; if (ux&uy&uz&uw) { // All elements are greater CR = XM_CRMASK_CR6TRUE; } else if (!(ux|uy|uz|uw)) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; XMVECTOR Control; Control.vector4_u32[0] = ux; Control.vector4_u32[1] = uy; Control.vector4_u32[2] = uz; Control.vector4_u32[3] = uw; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgeq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { // All elements are greater or equal CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { // All elements are not greater or equal CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vResult;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); uint32_t CR = 0; int iTest = _mm_movemask_ps(vTemp); if (iTest==0xf) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { // All elements are not greater CR = XM_CRMASK_CR6FALSE; } *pCR = CR; return vTemp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorLess( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_f32[0] < V2.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_f32[1] < V2.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_f32[2] < V2.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_f32[3] < V2.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vcltq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_cmplt_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorLessOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V1.vector4_f32[0] <= V2.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V1.vector4_f32[1] <= V2.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V1.vector4_f32[2] <= V2.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V1.vector4_f32[3] <= V2.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vcleq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_cmple_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorInBounds( FXMVECTOR V, FXMVECTOR Bounds){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = (V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) ? 0xFFFFFFFF : 0; Control.vector4_u32[1] = (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) ? 0xFFFFFFFF : 0; Control.vector4_u32[2] = (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2]) ? 0xFFFFFFFF : 0; Control.vector4_u32[3] = (V.vector4_f32[3] <= Bounds.vector4_f32[3] && V.vector4_f32[3] >= -Bounds.vector4_f32[3]) ? 0xFFFFFFFF : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = vcleq_f32(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = vnegq_f32(Bounds); // Test if greater or equal (Reversed) vTemp2 = vcleq_f32(vTemp2,V); // Blend answers vTemp1 = vandq_u32(vTemp1,vTemp2); return vTemp1;#elif defined(_XM_SSE_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = _mm_cmple_ps(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = _mm_mul_ps(Bounds,g_XMNegativeOne); // Test if greater or equal (Reversed) vTemp2 = _mm_cmple_ps(vTemp2,V); // Blend answers vTemp1 = _mm_and_ps(vTemp1,vTemp2); return vTemp1;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMVECTOR XMVectorInBoundsR( uint32_t* pCR, FXMVECTOR V, FXMVECTOR Bounds){ assert( pCR != NULL );#if defined(_XM_NO_INTRINSICS_) uint32_t ux = (V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) ? 0xFFFFFFFFU : 0; uint32_t uy = (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) ? 0xFFFFFFFFU : 0; uint32_t uz = (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2]) ? 0xFFFFFFFFU : 0; uint32_t uw = (V.vector4_f32[3] <= Bounds.vector4_f32[3] && V.vector4_f32[3] >= -Bounds.vector4_f32[3]) ? 0xFFFFFFFFU : 0; uint32_t CR = 0; if (ux&uy&uz&uw) { // All elements are in bounds CR = XM_CRMASK_CR6BOUNDS; } *pCR = CR; XMVECTOR Control; Control.vector4_u32[0] = ux; Control.vector4_u32[1] = uy; Control.vector4_u32[2] = uz; Control.vector4_u32[3] = uw; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = vcleq_f32(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = vnegq_f32(Bounds); // Test if greater or equal (Reversed) vTemp2 = vcleq_f32(vTemp2,V); // Blend answers vTemp1 = vandq_u32(vTemp1,vTemp2); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTemp1), vget_high_u8(vTemp1)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { // All elements are in bounds CR = XM_CRMASK_CR6BOUNDS; } *pCR = CR; return vTemp1;#elif defined(_XM_SSE_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = _mm_cmple_ps(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = _mm_mul_ps(Bounds,g_XMNegativeOne); // Test if greater or equal (Reversed) vTemp2 = _mm_cmple_ps(vTemp2,V); // Blend answers vTemp1 = _mm_and_ps(vTemp1,vTemp2); uint32_t CR = 0; if (_mm_movemask_ps(vTemp1)==0xf) { // All elements are in bounds CR = XM_CRMASK_CR6BOUNDS; } *pCR = CR; return vTemp1;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorIsNaN( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = XMISNAN(V.vector4_f32[0]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[1] = XMISNAN(V.vector4_f32[1]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[2] = XMISNAN(V.vector4_f32[2]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[3] = XMISNAN(V.vector4_f32[3]) ? 0xFFFFFFFFU : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test against itself. NaN is always not equal __n128 vTempNan = vceqq_f32( V, V ); // Flip results return vmvnq_u32( vTempNan );#elif defined(_XM_SSE_INTRINSICS_) // Test against itself. NaN is always not equal return _mm_cmpneq_ps(V,V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorIsInfinite( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Control; Control.vector4_u32[0] = XMISINF(V.vector4_f32[0]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[1] = XMISINF(V.vector4_f32[1]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[2] = XMISINF(V.vector4_f32[2]) ? 0xFFFFFFFFU : 0; Control.vector4_u32[3] = XMISINF(V.vector4_f32[3]) ? 0xFFFFFFFFU : 0; return Control;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Mask off the sign bit __n128 vTemp = vandq_u32(V,g_XMAbsMask); // Compare to infinity vTemp = vceqq_f32(vTemp,g_XMInfinity); // If any are infinity, the signs are true. return vTemp;#elif defined(_XM_SSE_INTRINSICS_) // Mask off the sign bit __m128 vTemp = _mm_and_ps(V,g_XMAbsMask); // Compare to infinity vTemp = _mm_cmpeq_ps(vTemp,g_XMInfinity); // If any are infinity, the signs are true. return vTemp;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Rounding and clamping operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline XMVECTOR XMVectorMin( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = (V1.vector4_f32[0] < V2.vector4_f32[0]) ? V1.vector4_f32[0] : V2.vector4_f32[0]; Result.vector4_f32[1] = (V1.vector4_f32[1] < V2.vector4_f32[1]) ? V1.vector4_f32[1] : V2.vector4_f32[1]; Result.vector4_f32[2] = (V1.vector4_f32[2] < V2.vector4_f32[2]) ? V1.vector4_f32[2] : V2.vector4_f32[2]; Result.vector4_f32[3] = (V1.vector4_f32[3] < V2.vector4_f32[3]) ? V1.vector4_f32[3] : V2.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vminq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_min_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorMax( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = (V1.vector4_f32[0] > V2.vector4_f32[0]) ? V1.vector4_f32[0] : V2.vector4_f32[0]; Result.vector4_f32[1] = (V1.vector4_f32[1] > V2.vector4_f32[1]) ? V1.vector4_f32[1] : V2.vector4_f32[1]; Result.vector4_f32[2] = (V1.vector4_f32[2] > V2.vector4_f32[2]) ? V1.vector4_f32[2] : V2.vector4_f32[2]; Result.vector4_f32[3] = (V1.vector4_f32[3] > V2.vector4_f32[3]) ? V1.vector4_f32[3] : V2.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmaxq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_max_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorRound( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) const XMVECTOR Zero = XMVectorZero(); const XMVECTOR BiasPos = XMVectorReplicate(0.5f); const XMVECTOR BiasNeg = XMVectorReplicate(-0.5f); XMVECTOR Bias = XMVectorLess(V, Zero); Bias = XMVectorSelect(BiasPos, BiasNeg, Bias); XMVECTOR Result = XMVectorAdd(V, Bias); Result = XMVectorTruncate(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vTest = vabsq_f32( V ); vTest = vcltq_f32( vTest, g_XMNoFraction ); __n128 Bias = vcltq_f32( V, vdupq_n_u32(0) ); __n128 BiasPos = vdupq_n_f32( 0.5f ); __n128 BiasNeg = vdupq_n_f32( -0.5f ); Bias = vbslq_f32( Bias, BiasNeg, BiasPos ); __n128 V0 = vaddq_f32( V, Bias ); __n128 vInt = vcvtq_s32_f32( V0 ); __n128 vResult = vcvtq_f32_s32( vInt ); // All numbers less than 8388608 will use the round to int // All others, use the ORIGINAL value return vbslq_f32( vTest, vResult, V );#elif defined(_XM_SSE_INTRINSICS_) // To handle NAN, INF and numbers greater than 8388608, use masking // Get the abs value __m128i vTest = _mm_and_si128(_mm_castps_si128(V),g_XMAbsMask); // Test for greater than 8388608 (All floats with NO fractionals, NAN and INF vTest = _mm_cmplt_epi32(vTest,g_XMNoFraction); // Convert to int and back to float for rounding __m128i vInt = _mm_cvtps_epi32(V); // Convert back to floats XMVECTOR vResult = _mm_cvtepi32_ps(vInt); // All numbers less than 8388608 will use the round to int vResult = _mm_and_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); // All others, use the ORIGINAL value vTest = _mm_andnot_si128(vTest,_mm_castps_si128(V)); vResult = _mm_or_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorTruncate( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; uint32_t i; // Avoid C4701 Result.vector4_f32[0] = 0.0f; for (i = 0; i < 4; i++) { if (XMISNAN(V.vector4_f32[i])) { Result.vector4_u32[i] = 0x7FC00000; } else if (fabsf(V.vector4_f32[i]) < 8388608.0f) { Result.vector4_f32[i] = (float)((int32_t)V.vector4_f32[i]); } else { Result.vector4_f32[i] = V.vector4_f32[i]; } } return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vTest = vabsq_f32( V ); vTest = vcltq_f32( vTest, g_XMNoFraction ); __n128 vInt = vcvtq_s32_f32( V ); __n128 vResult = vcvtq_f32_s32( vInt ); // All numbers less than 8388608 will use the round to int // All others, use the ORIGINAL value return vbslq_f32( vTest, vResult, V );#elif defined(_XM_SSE_INTRINSICS_) // To handle NAN, INF and numbers greater than 8388608, use masking // Get the abs value __m128i vTest = _mm_and_si128(_mm_castps_si128(V),g_XMAbsMask); // Test for greater than 8388608 (All floats with NO fractionals, NAN and INF vTest = _mm_cmplt_epi32(vTest,g_XMNoFraction); // Convert to int and back to float for rounding with truncation __m128i vInt = _mm_cvttps_epi32(V); // Convert back to floats XMVECTOR vResult = _mm_cvtepi32_ps(vInt); // All numbers less than 8388608 will use the round to int vResult = _mm_and_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); // All others, use the ORIGINAL value vTest = _mm_andnot_si128(vTest,_mm_castps_si128(V)); vResult = _mm_or_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorFloor( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { floorf(V.vector4_f32[0]), floorf(V.vector4_f32[1]), floorf(V.vector4_f32[2]), floorf(V.vector4_f32[3]) }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 V0 = vsubq_f32( V, vdupq_n_u32(0x3EFFFFA0) ); return XMVectorRound(V0);#elif defined(_XM_SSE_INTRINSICS_) // To handle NAN, INF and numbers greater than 8388608, use masking // Get the abs value __m128i vTest = _mm_and_si128(_mm_castps_si128(V),g_XMAbsMask); // Test for greater than 8388608 (All floats with NO fractionals, NAN and INF vTest = _mm_cmplt_epi32(vTest,g_XMNoFraction); // Convert to int and back to float for rounding XMVECTOR vResult = _mm_sub_ps(V,g_XMOneHalfMinusEpsilon); __m128i vInt = _mm_cvtps_epi32(vResult); // Convert back to floats vResult = _mm_cvtepi32_ps(vInt); // All numbers less than 8388608 will use the round to int vResult = _mm_and_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); // All others, use the ORIGINAL value vTest = _mm_andnot_si128(vTest,_mm_castps_si128(V)); vResult = _mm_or_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorCeiling( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { ceilf(V.vector4_f32[0]), ceilf(V.vector4_f32[1]), ceilf(V.vector4_f32[2]), ceilf(V.vector4_f32[3]) }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 V0 = vaddq_f32( V, vdupq_n_u32(0x3EFFFFA0) ); return XMVectorRound(V0);#elif defined(_XM_SSE_INTRINSICS_) // To handle NAN, INF and numbers greater than 8388608, use masking // Get the abs value __m128i vTest = _mm_and_si128(_mm_castps_si128(V),g_XMAbsMask); // Test for greater than 8388608 (All floats with NO fractionals, NAN and INF vTest = _mm_cmplt_epi32(vTest,g_XMNoFraction); // Convert to int and back to float for rounding XMVECTOR vResult = _mm_add_ps(V,g_XMOneHalfMinusEpsilon); __m128i vInt = _mm_cvtps_epi32(vResult); // Convert back to floats vResult = _mm_cvtepi32_ps(vInt); // All numbers less than 8388608 will use the round to int vResult = _mm_and_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); // All others, use the ORIGINAL value vTest = _mm_andnot_si128(vTest,_mm_castps_si128(V)); vResult = _mm_or_ps(vResult,reinterpret_cast<const XMVECTOR *>(&vTest)[0]); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorClamp( FXMVECTOR V, FXMVECTOR Min, FXMVECTOR Max){ assert(XMVector4LessOrEqual(Min, Max));#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVectorMax(Min, V); Result = XMVectorMin(Max, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR vResult; vResult = vmaxq_f32(Min,V); vResult = vminq_f32(vResult,Max); return vResult;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult; vResult = _mm_max_ps(Min,V); vResult = _mm_min_ps(vResult,Max); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSaturate( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) const XMVECTOR Zero = XMVectorZero(); return XMVectorClamp(V, Zero, g_XMOne.v);#elif defined(_XM_ARM_NEON_INTRINSICS_) // Set <0 to 0 XMVECTOR vResult = vmaxq_f32(V, vdupq_n_u32(0) ); // Set>1 to 1 return vminq_f32(vResult, vdupq_n_f32(1.0f) );#elif defined(_XM_SSE_INTRINSICS_) // Set <0 to 0 XMVECTOR vResult = _mm_max_ps(V,g_XMZero); // Set>1 to 1 return _mm_min_ps(vResult,g_XMOne);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Bitwise logical operations//------------------------------------------------------------------------------inline XMVECTOR XMVectorAndInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = V1.vector4_u32[0] & V2.vector4_u32[0]; Result.vector4_u32[1] = V1.vector4_u32[1] & V2.vector4_u32[1]; Result.vector4_u32[2] = V1.vector4_u32[2] & V2.vector4_u32[2]; Result.vector4_u32[3] = V1.vector4_u32[3] & V2.vector4_u32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vandq_u32(V1,V2);#elif defined(_XM_SSE_INTRINSICS_) return _mm_and_ps(V1,V2);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorAndCInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = V1.vector4_u32[0] & ~V2.vector4_u32[0]; Result.vector4_u32[1] = V1.vector4_u32[1] & ~V2.vector4_u32[1]; Result.vector4_u32[2] = V1.vector4_u32[2] & ~V2.vector4_u32[2]; Result.vector4_u32[3] = V1.vector4_u32[3] & ~V2.vector4_u32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vbicq_u32(V1,V2);#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_andnot_si128( _mm_castps_si128(V2), _mm_castps_si128(V1) ); return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorOrInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = V1.vector4_u32[0] | V2.vector4_u32[0]; Result.vector4_u32[1] = V1.vector4_u32[1] | V2.vector4_u32[1]; Result.vector4_u32[2] = V1.vector4_u32[2] | V2.vector4_u32[2]; Result.vector4_u32[3] = V1.vector4_u32[3] | V2.vector4_u32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vorrq_u32(V1,V2);#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_or_si128( _mm_castps_si128(V1), _mm_castps_si128(V2) ); return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorNorInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = ~(V1.vector4_u32[0] | V2.vector4_u32[0]); Result.vector4_u32[1] = ~(V1.vector4_u32[1] | V2.vector4_u32[1]); Result.vector4_u32[2] = ~(V1.vector4_u32[2] | V2.vector4_u32[2]); Result.vector4_u32[3] = ~(V1.vector4_u32[3] | V2.vector4_u32[3]); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 Result = vorrq_u32(V1,V2); return vbicq_u32(g_XMNegOneMask, Result);#elif defined(_XM_SSE_INTRINSICS_) __m128i Result; Result = _mm_or_si128( _mm_castps_si128(V1), _mm_castps_si128(V2) ); Result = _mm_andnot_si128( Result,g_XMNegOneMask); return reinterpret_cast<__m128 *>(&Result)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorXorInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_u32[0] = V1.vector4_u32[0] ^ V2.vector4_u32[0]; Result.vector4_u32[1] = V1.vector4_u32[1] ^ V2.vector4_u32[1]; Result.vector4_u32[2] = V1.vector4_u32[2] ^ V2.vector4_u32[2]; Result.vector4_u32[3] = V1.vector4_u32[3] ^ V2.vector4_u32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return veorq_u32(V1,V2);#elif defined(_XM_SSE_INTRINSICS_) __m128i V = _mm_xor_si128( _mm_castps_si128(V1), _mm_castps_si128(V2) ); return reinterpret_cast<__m128 *>(&V)[0];#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Computation operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline XMVECTOR XMVectorNegate( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = -V.vector4_f32[0]; Result.vector4_f32[1] = -V.vector4_f32[1]; Result.vector4_f32[2] = -V.vector4_f32[2]; Result.vector4_f32[3] = -V.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vnegq_f32(V);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR Z; Z = _mm_setzero_ps(); return _mm_sub_ps( Z, V );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorAdd( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = V1.vector4_f32[0] + V2.vector4_f32[0]; Result.vector4_f32[1] = V1.vector4_f32[1] + V2.vector4_f32[1]; Result.vector4_f32[2] = V1.vector4_f32[2] + V2.vector4_f32[2]; Result.vector4_f32[3] = V1.vector4_f32[3] + V2.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vaddq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_add_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorAddAngles( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) const XMVECTOR Zero = XMVectorZero(); // Add the given angles together. If the range of V1 is such // that -Pi <= V1 < Pi and the range of V2 is such that // -2Pi <= V2 <= 2Pi, then the range of the resulting angle // will be -Pi <= Result < Pi. XMVECTOR Result = XMVectorAdd(V1, V2); XMVECTOR Mask = XMVectorLess(Result, g_XMNegativePi.v); XMVECTOR Offset = XMVectorSelect(Zero, g_XMTwoPi.v, Mask); Mask = XMVectorGreaterOrEqual(Result, g_XMPi.v); Offset = XMVectorSelect(Offset, g_XMNegativeTwoPi.v, Mask); Result = XMVectorAdd(Result, Offset); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Adjust the angles __n128 vResult = vaddq_f32(V1,V2); // Less than Pi? __n128 vOffset = vcltq_f32(vResult,g_XMNegativePi); vOffset = vandq_u32(vOffset,g_XMTwoPi); // Add 2Pi to all entries less than -Pi vResult = vaddq_f32(vResult,vOffset); // Greater than or equal to Pi? vOffset = vcgeq_f32(vResult,g_XMPi); vOffset = vandq_u32(vOffset,g_XMTwoPi); // Sub 2Pi to all entries greater than Pi vResult = vsubq_f32(vResult,vOffset); return vResult;#elif defined(_XM_SSE_INTRINSICS_) // Adjust the angles XMVECTOR vResult = _mm_add_ps(V1,V2); // Less than Pi? XMVECTOR vOffset = _mm_cmplt_ps(vResult,g_XMNegativePi); vOffset = _mm_and_ps(vOffset,g_XMTwoPi); // Add 2Pi to all entries less than -Pi vResult = _mm_add_ps(vResult,vOffset); // Greater than or equal to Pi? vOffset = _mm_cmpge_ps(vResult,g_XMPi); vOffset = _mm_and_ps(vOffset,g_XMTwoPi); // Sub 2Pi to all entries greater than Pi vResult = _mm_sub_ps(vResult,vOffset); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSubtract( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = V1.vector4_f32[0] - V2.vector4_f32[0]; Result.vector4_f32[1] = V1.vector4_f32[1] - V2.vector4_f32[1]; Result.vector4_f32[2] = V1.vector4_f32[2] - V2.vector4_f32[2]; Result.vector4_f32[3] = V1.vector4_f32[3] - V2.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vsubq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_sub_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSubtractAngles( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) const XMVECTOR Zero = XMVectorZero(); // Subtract the given angles. If the range of V1 is such // that -Pi <= V1 < Pi and the range of V2 is such that // -2Pi <= V2 <= 2Pi, then the range of the resulting angle // will be -Pi <= Result < Pi. XMVECTOR Result = XMVectorSubtract(V1, V2); XMVECTOR Mask = XMVectorLess(Result, g_XMNegativePi.v); XMVECTOR Offset = XMVectorSelect(Zero, g_XMTwoPi.v, Mask); Mask = XMVectorGreaterOrEqual(Result, g_XMPi.v); Offset = XMVectorSelect(Offset, g_XMNegativeTwoPi.v, Mask); Result = XMVectorAdd(Result, Offset); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Adjust the angles __n128 vResult = vsubq_f32(V1,V2); // Less than Pi? __n128 vOffset = vcltq_f32(vResult,g_XMNegativePi); vOffset = vandq_u32(vOffset,g_XMTwoPi); // Add 2Pi to all entries less than -Pi vResult = vaddq_f32(vResult,vOffset); // Greater than or equal to Pi? vOffset = vcgeq_f32(vResult,g_XMPi); vOffset = vandq_u32(vOffset,g_XMTwoPi); // Sub 2Pi to all entries greater than Pi vResult = vsubq_f32(vResult,vOffset); return vResult;#elif defined(_XM_SSE_INTRINSICS_) // Adjust the angles XMVECTOR vResult = _mm_sub_ps(V1,V2); // Less than Pi? XMVECTOR vOffset = _mm_cmplt_ps(vResult,g_XMNegativePi); vOffset = _mm_and_ps(vOffset,g_XMTwoPi); // Add 2Pi to all entries less than -Pi vResult = _mm_add_ps(vResult,vOffset); // Greater than or equal to Pi? vOffset = _mm_cmpge_ps(vResult,g_XMPi); vOffset = _mm_and_ps(vOffset,g_XMTwoPi); // Sub 2Pi to all entries greater than Pi vResult = _mm_sub_ps(vResult,vOffset); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorMultiply( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result = { V1.vector4_f32[0] * V2.vector4_f32[0], V1.vector4_f32[1] * V2.vector4_f32[1], V1.vector4_f32[2] * V2.vector4_f32[2], V1.vector4_f32[3] * V2.vector4_f32[3] }; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmulq_f32( V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) return _mm_mul_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorMultiplyAdd( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { (V1.vector4_f32[0] * V2.vector4_f32[0]) + V3.vector4_f32[0], (V1.vector4_f32[1] * V2.vector4_f32[1]) + V3.vector4_f32[1], (V1.vector4_f32[2] * V2.vector4_f32[2]) + V3.vector4_f32[2], (V1.vector4_f32[3] * V2.vector4_f32[3]) + V3.vector4_f32[3] }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmlaq_f32( V3, V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_mul_ps( V1, V2 ); return _mm_add_ps(vResult, V3 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorDivide( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = V1.vector4_f32[0] / V2.vector4_f32[0]; Result.vector4_f32[1] = V1.vector4_f32[1] / V2.vector4_f32[1]; Result.vector4_f32[2] = V1.vector4_f32[2] / V2.vector4_f32[2]; Result.vector4_f32[3] = V1.vector4_f32[3] / V2.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // 2 iterations of Newton-Raphson refinement of reciprocal __n128 Reciprocal = vrecpeq_f32(V2); __n128 S = vrecpsq_f32( Reciprocal, V2 ); Reciprocal = vmulq_f32( S, Reciprocal ); S = vrecpsq_f32( Reciprocal, V2 ); Reciprocal = vmulq_f32( S, Reciprocal ); return vmulq_f32( V1, Reciprocal );#elif defined(_XM_SSE_INTRINSICS_) return _mm_div_ps( V1, V2 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorNegativeMultiplySubtract( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { V3.vector4_f32[0] - (V1.vector4_f32[0] * V2.vector4_f32[0]), V3.vector4_f32[1] - (V1.vector4_f32[1] * V2.vector4_f32[1]), V3.vector4_f32[2] - (V1.vector4_f32[2] * V2.vector4_f32[2]), V3.vector4_f32[3] - (V1.vector4_f32[3] * V2.vector4_f32[3]) }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmlsq_f32( V3, V1, V2 );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR R = _mm_mul_ps( V1, V2 ); return _mm_sub_ps( V3, R );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorScale( FXMVECTOR V, float ScaleFactor){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { V.vector4_f32[0] * ScaleFactor, V.vector4_f32[1] * ScaleFactor, V.vector4_f32[2] * ScaleFactor, V.vector4_f32[3] * ScaleFactor }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vmulq_n_f32( V, ScaleFactor );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_set_ps1(ScaleFactor); return _mm_mul_ps(vResult,V);#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorReciprocalEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = 1.f / V.vector4_f32[0]; Result.vector4_f32[1] = 1.f / V.vector4_f32[1]; Result.vector4_f32[2] = 1.f / V.vector4_f32[2]; Result.vector4_f32[3] = 1.f / V.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vrecpeq_f32(V);#elif defined(_XM_SSE_INTRINSICS_) return _mm_rcp_ps(V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorReciprocal( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = 1.f / V.vector4_f32[0]; Result.vector4_f32[1] = 1.f / V.vector4_f32[1]; Result.vector4_f32[2] = 1.f / V.vector4_f32[2]; Result.vector4_f32[3] = 1.f / V.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // 2 iterations of Newton-Raphson refinement __n128 Reciprocal = vrecpeq_f32(V); __n128 S = vrecpsq_f32( Reciprocal, V ); Reciprocal = vmulq_f32( S, Reciprocal ); S = vrecpsq_f32( Reciprocal, V ); return vmulq_f32( S, Reciprocal );#elif defined(_XM_SSE_INTRINSICS_) return _mm_div_ps(g_XMOne,V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Return an estimated square rootinline XMVECTOR XMVectorSqrtEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = sqrtf( V.vector4_f32[0] ); Result.vector4_f32[1] = sqrtf( V.vector4_f32[1] ); Result.vector4_f32[2] = sqrtf( V.vector4_f32[2] ); Result.vector4_f32[3] = sqrtf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // 1 iteration of Newton-Raphson refinment of sqrt __n128 S0 = vrsqrteq_f32(V); __n128 P0 = vmulq_f32( V, S0 ); __n128 R0 = vrsqrtsq_f32( P0, S0 ); __n128 S1 = vmulq_f32( S0, R0 ); XMVECTOR VEqualsInfinity = XMVectorEqualInt(V, g_XMInfinity.v); XMVECTOR VEqualsZero = XMVectorEqual(V, vdupq_n_f32(0) ); __n128 Result = vmulq_f32( V, S1 ); XMVECTOR Select = XMVectorEqualInt(VEqualsInfinity, VEqualsZero); return XMVectorSelect(V, Result, Select);#elif defined(_XM_SSE_INTRINSICS_) return _mm_sqrt_ps(V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSqrt( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = sqrtf( V.vector4_f32[0] ); Result.vector4_f32[1] = sqrtf( V.vector4_f32[1] ); Result.vector4_f32[2] = sqrtf( V.vector4_f32[2] ); Result.vector4_f32[3] = sqrtf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // 3 iterations of Newton-Raphson refinment of sqrt __n128 S0 = vrsqrteq_f32(V); __n128 P0 = vmulq_f32( V, S0 ); __n128 R0 = vrsqrtsq_f32( P0, S0 ); __n128 S1 = vmulq_f32( S0, R0 ); __n128 P1 = vmulq_f32( V, S1 ); __n128 R1 = vrsqrtsq_f32( P1, S1 ); __n128 S2 = vmulq_f32( S1, R1 ); __n128 P2 = vmulq_f32( V, S2 ); __n128 R2 = vrsqrtsq_f32( P2, S2 ); __n128 S3 = vmulq_f32( S2, R2 ); XMVECTOR VEqualsInfinity = XMVectorEqualInt(V, g_XMInfinity.v); XMVECTOR VEqualsZero = XMVectorEqual(V, vdupq_n_f32(0) ); __n128 Result = vmulq_f32( V, S3 ); XMVECTOR Select = XMVectorEqualInt(VEqualsInfinity, VEqualsZero); return XMVectorSelect(V, Result, Select);#elif defined(_XM_SSE_INTRINSICS_) return _mm_sqrt_ps(V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorReciprocalSqrtEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = 1.f / sqrtf( V.vector4_f32[0] ); Result.vector4_f32[1] = 1.f / sqrtf( V.vector4_f32[1] ); Result.vector4_f32[2] = 1.f / sqrtf( V.vector4_f32[2] ); Result.vector4_f32[3] = 1.f / sqrtf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vrsqrteq_f32(V);#elif defined(_XM_SSE_INTRINSICS_) return _mm_rsqrt_ps(V);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorReciprocalSqrt( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = 1.f / sqrtf( V.vector4_f32[0] ); Result.vector4_f32[1] = 1.f / sqrtf( V.vector4_f32[1] ); Result.vector4_f32[2] = 1.f / sqrtf( V.vector4_f32[2] ); Result.vector4_f32[3] = 1.f / sqrtf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // 2 iterations of Newton-Raphson refinement of reciprocal __n128 S0 = vrsqrteq_f32(V); __n128 P0 = vmulq_f32( V, S0 ); __n128 R0 = vrsqrtsq_f32( P0, S0 ); __n128 S1 = vmulq_f32( S0, R0 ); __n128 P1 = vmulq_f32( V, S1 ); __n128 R1 = vrsqrtsq_f32( P1, S1 ); return vmulq_f32( S1, R1 );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_sqrt_ps(V); vResult = _mm_div_ps(g_XMOne,vResult); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorExp( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = powf(2.0f, V.vector4_f32[0]); Result.vector4_f32[1] = powf(2.0f, V.vector4_f32[1]); Result.vector4_f32[2] = powf(2.0f, V.vector4_f32[2]); Result.vector4_f32[3] = powf(2.0f, V.vector4_f32[3]); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTORF32 vResult = { powf(2.0f,vgetq_lane_f32(V, 0)), powf(2.0f,vgetq_lane_f32(V, 1)), powf(2.0f,vgetq_lane_f32(V, 2)), powf(2.0f,vgetq_lane_f32(V, 3)) }; return vResult;#elif defined(_XM_SSE_INTRINSICS_) __declspec(align(16)) float a[4]; _mm_store_ps( a, V ); XMVECTOR vResult = _mm_setr_ps( powf(2.0f,a[0]), powf(2.0f,a[1]), powf(2.0f,a[2]), powf(2.0f,a[3])); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorLog( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) const float fScale = 1.4426950f; // (1.0f / logf(2.0f)); XMVECTOR Result; Result.vector4_f32[0] = logf(V.vector4_f32[0])*fScale; Result.vector4_f32[1] = logf(V.vector4_f32[1])*fScale; Result.vector4_f32[2] = logf(V.vector4_f32[2])*fScale; Result.vector4_f32[3] = logf(V.vector4_f32[3])*fScale; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR vScale = vdupq_n_f32(1.0f / logf(2.0f)); XMVECTORF32 vResult = { logf(vgetq_lane_f32(V, 0)), logf(vgetq_lane_f32(V, 1)), logf(vgetq_lane_f32(V, 2)), logf(vgetq_lane_f32(V, 3)) }; return vmulq_f32( vResult, vScale );#elif defined(_XM_SSE_INTRINSICS_) __declspec(align(16)) float a[4]; _mm_store_ps( a, V ); XMVECTOR vScale = _mm_set_ps1(1.0f / logf(2.0f)); XMVECTOR vResult = _mm_setr_ps( logf(a[0]), logf(a[1]), logf(a[2]), logf(a[3])); vResult = _mm_mul_ps(vResult,vScale); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorPow( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = powf(V1.vector4_f32[0], V2.vector4_f32[0]); Result.vector4_f32[1] = powf(V1.vector4_f32[1], V2.vector4_f32[1]); Result.vector4_f32[2] = powf(V1.vector4_f32[2], V2.vector4_f32[2]); Result.vector4_f32[3] = powf(V1.vector4_f32[3], V2.vector4_f32[3]); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTORF32 vResult = { powf(vgetq_lane_f32(V1, 0), vgetq_lane_f32(V2, 0)), powf(vgetq_lane_f32(V1, 1), vgetq_lane_f32(V2, 1)), powf(vgetq_lane_f32(V1, 2), vgetq_lane_f32(V2, 2)), powf(vgetq_lane_f32(V1, 3), vgetq_lane_f32(V2, 3)) }; return vResult;#elif defined(_XM_SSE_INTRINSICS_) __declspec(align(16)) float a[4]; __declspec(align(16)) float b[4]; _mm_store_ps( a, V1 ); _mm_store_ps( b, V2 ); XMVECTOR vResult = _mm_setr_ps( powf(a[0],b[0]), powf(a[1],b[1]), powf(a[2],b[2]), powf(a[3],b[3])); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorAbs( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { fabsf(V.vector4_f32[0]), fabsf(V.vector4_f32[1]), fabsf(V.vector4_f32[2]), fabsf(V.vector4_f32[3]) }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) return vabsq_f32( V );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_setzero_ps(); vResult = _mm_sub_ps(vResult,V); vResult = _mm_max_ps(vResult,V); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorMod( FXMVECTOR V1, FXMVECTOR V2){ // V1 % V2 = V1 - V2 * truncate(V1 / V2)#if defined(_XM_NO_INTRINSICS_) XMVECTOR Quotient = XMVectorDivide(V1, V2); Quotient = XMVectorTruncate(Quotient); XMVECTOR Result = XMVectorNegativeMultiplySubtract(V2, Quotient, V1); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR vResult = XMVectorDivide(V1, V2); vResult = XMVectorTruncate(vResult); return vmlsq_f32( V1, vResult, V2 );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = _mm_div_ps(V1, V2); vResult = XMVectorTruncate(vResult); vResult = _mm_mul_ps(vResult,V2); vResult = _mm_sub_ps(V1,vResult); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorModAngles( FXMVECTOR Angles){#if defined(_XM_NO_INTRINSICS_) XMVECTOR V; XMVECTOR Result; // Modulo the range of the given angles such that -XM_PI <= Angles < XM_PI V = XMVectorMultiply(Angles, g_XMReciprocalTwoPi.v); V = XMVectorRound(V); Result = XMVectorNegativeMultiplySubtract(g_XMTwoPi.v, V, Angles); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Modulo the range of the given angles such that -XM_PI <= Angles < XM_PI XMVECTOR vResult = vmulq_f32(Angles,g_XMReciprocalTwoPi); // Use the inline function due to complexity for rounding vResult = XMVectorRound(vResult); return vmlsq_f32( Angles, vResult, g_XMTwoPi );#elif defined(_XM_SSE_INTRINSICS_) // Modulo the range of the given angles such that -XM_PI <= Angles < XM_PI XMVECTOR vResult = _mm_mul_ps(Angles,g_XMReciprocalTwoPi); // Use the inline function due to complexity for rounding vResult = XMVectorRound(vResult); vResult = _mm_mul_ps(vResult,g_XMTwoPi); vResult = _mm_sub_ps(Angles,vResult); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSin( FXMVECTOR V){ // 11-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarSin( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarSin( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarSin( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarSin( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with sin(y) = sin(x). __n128 sign = vandq_u32(x, g_XMNegativeZero); __n128 c = vorrq_u32(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __n128 absx = vabsq_f32( x ); __n128 rflx = vsubq_f32(c, x); __n128 comp = vcleq_f32(absx, g_XMHalfPi); x = vbslq_f32( comp, x, rflx ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation const XMVECTOR SC1 = g_XMSinCoefficients1; XMVECTOR Result = vdupq_lane_f32(vget_low_f32(SC1), 0); const XMVECTOR SC0 = g_XMSinCoefficients0; XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_high_f32(SC0), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(SC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(SC0), 0); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); Result = vmulq_f32(Result, x); return Result;#elif defined(_XM_SSE_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with sin(y) = sin(x). __m128 sign = _mm_and_ps(x, g_XMNegativeZero); __m128 c = _mm_or_ps(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __m128 absx = _mm_andnot_ps(sign, x); // |x| __m128 rflx = _mm_sub_ps(c, x); __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi); __m128 select0 = _mm_and_ps(comp, x); __m128 select1 = _mm_andnot_ps(comp, rflx); x = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation const XMVECTOR SC1 = g_XMSinCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( SC1, _MM_SHUFFLE(0, 0, 0, 0) ); __m128 Result = _mm_mul_ps(vConstants, x2); const XMVECTOR SC0 = g_XMSinCoefficients0; vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(3, 3, 3, 3) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, x); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorCos( FXMVECTOR V){ // 10-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarCos( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarCos( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarCos( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarCos( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Map V to x in [-pi,pi]. XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x). __n128 sign = vandq_u32(x, g_XMNegativeZero); __n128 c = vorrq_u32(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __n128 absx = vabsq_f32( x ); __n128 rflx = vsubq_f32(c, x); __n128 comp = vcleq_f32(absx, g_XMHalfPi); x = vbslq_f32( comp, x, rflx ); sign = vbslq_f32( comp, g_XMOne, g_XMNegativeOne ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation const XMVECTOR CC1 = g_XMCosCoefficients1; XMVECTOR Result = vdupq_lane_f32(vget_low_f32(CC1), 0); const XMVECTOR CC0 = g_XMCosCoefficients0; XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(CC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_high_f32(CC0), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(CC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(CC0), 0); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); Result = vmulq_f32(Result, sign); return Result;#elif defined(_XM_SSE_INTRINSICS_) // Map V to x in [-pi,pi]. XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x). XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero); __m128 c = _mm_or_ps(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __m128 absx = _mm_andnot_ps(sign, x); // |x| __m128 rflx = _mm_sub_ps(c, x); __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi); __m128 select0 = _mm_and_ps(comp, x); __m128 select1 = _mm_andnot_ps(comp, rflx); x = _mm_or_ps(select0, select1); select0 = _mm_and_ps(comp, g_XMOne); select1 = _mm_andnot_ps(comp, g_XMNegativeOne); sign = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation const XMVECTOR CC1 = g_XMCosCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( CC1, _MM_SHUFFLE(0, 0, 0, 0) ); __m128 Result = _mm_mul_ps(vConstants, x2); const XMVECTOR CC0 = g_XMCosCoefficients0; vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(3, 3, 3, 3) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, sign); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline void XMVectorSinCos( XMVECTOR* pSin, XMVECTOR* pCos, FXMVECTOR V){ assert(pSin != NULL); assert(pCos != NULL); // 11/10-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Sin; XMVECTOR Cos; XMScalarSinCos(&Sin.vector4_f32[0], &Cos.vector4_f32[0], V.vector4_f32[0]); XMScalarSinCos(&Sin.vector4_f32[1], &Cos.vector4_f32[1], V.vector4_f32[1]); XMScalarSinCos(&Sin.vector4_f32[2], &Cos.vector4_f32[2], V.vector4_f32[2]); XMScalarSinCos(&Sin.vector4_f32[3], &Cos.vector4_f32[3], V.vector4_f32[3]); *pSin = Sin; *pCos = Cos;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x). __n128 sign = vandq_u32(x, g_XMNegativeZero); __n128 c = vorrq_u32(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __n128 absx = vabsq_f32( x ); __n128 rflx = vsubq_f32(c, x); __n128 comp = vcleq_f32(absx, g_XMHalfPi); x = vbslq_f32( comp, x, rflx ); sign = vbslq_f32( comp, g_XMOne, g_XMNegativeOne ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation for sine const XMVECTOR SC1 = g_XMSinCoefficients1; XMVECTOR Result = vdupq_lane_f32(vget_low_f32(SC1), 0); const XMVECTOR SC0 = g_XMSinCoefficients0; XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_high_f32(SC0), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(SC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(SC0), 0); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); *pSin = vmulq_f32(Result, x); // Compute polynomial approximation for cosine const XMVECTOR CC1 = g_XMCosCoefficients1; Result = vdupq_lane_f32(vget_low_f32(CC1), 0); const XMVECTOR CC0 = g_XMCosCoefficients0; vConstants = vdupq_lane_f32(vget_high_f32(CC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_high_f32(CC0), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(CC0), 1); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(CC0), 0); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); *pCos = vmulq_f32(Result, sign);#elif defined(_XM_SSE_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with sin(y) = sin(x), cos(y) = sign*cos(x). XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero); __m128 c = _mm_or_ps(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __m128 absx = _mm_andnot_ps(sign, x); // |x| __m128 rflx = _mm_sub_ps(c, x); __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi); __m128 select0 = _mm_and_ps(comp, x); __m128 select1 = _mm_andnot_ps(comp, rflx); x = _mm_or_ps(select0, select1); select0 = _mm_and_ps(comp, g_XMOne); select1 = _mm_andnot_ps(comp, g_XMNegativeOne); sign = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation of sine const XMVECTOR SC1 = g_XMSinCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( SC1, _MM_SHUFFLE(0, 0, 0, 0) ); __m128 Result = _mm_mul_ps(vConstants, x2); const XMVECTOR SC0 = g_XMSinCoefficients0; vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(3, 3, 3, 3) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SC0, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, x); *pSin = Result; // Compute polynomial approximation of cosine const XMVECTOR CC1 = g_XMCosCoefficients1; vConstants = XM_PERMUTE_PS( CC1, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_mul_ps(vConstants, x2); const XMVECTOR CC0 = g_XMCosCoefficients0; vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(3, 3, 3, 3) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CC0, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, sign); *pCos = Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorTan( FXMVECTOR V){ // Cody and Waite algorithm to compute tangent.#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = tanf( V.vector4_f32[0] ); Result.vector4_f32[1] = tanf( V.vector4_f32[1] ); Result.vector4_f32[2] = tanf( V.vector4_f32[2] ); Result.vector4_f32[3] = tanf( V.vector4_f32[3] ); return Result;#elif defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 TanCoefficients0 = {1.0f, -4.667168334e-1f, 2.566383229e-2f, -3.118153191e-4f}; static const XMVECTORF32 TanCoefficients1 = {4.981943399e-7f, -1.333835001e-1f, 3.424887824e-3f, -1.786170734e-5f}; static const XMVECTORF32 TanConstants = {1.570796371f, 6.077100628e-11f, 0.000244140625f, 0.63661977228f /*2 / Pi*/ }; static const XMVECTORU32 Mask = {0x1, 0x1, 0x1, 0x1}; XMVECTOR TwoDivPi = XMVectorSplatW(TanConstants.v); XMVECTOR Zero = XMVectorZero(); XMVECTOR C0 = XMVectorSplatX(TanConstants.v); XMVECTOR C1 = XMVectorSplatY(TanConstants.v); XMVECTOR Epsilon = XMVectorSplatZ(TanConstants.v); XMVECTOR VA = XMVectorMultiply(V, TwoDivPi); VA = XMVectorRound(VA); XMVECTOR VC = XMVectorNegativeMultiplySubtract(VA, C0, V); XMVECTOR VB = XMVectorAbs(VA); VC = XMVectorNegativeMultiplySubtract(VA, C1, VC);#if defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_) VB = vcvtq_u32_f32( VB );#elif defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_) reinterpret_cast<__m128i *>(&VB)[0] = _mm_cvttps_epi32(VB);#else for (size_t i = 0; i < 4; i++) { VB.vector4_u32[i] = (uint32_t)VB.vector4_f32[i]; }#endif XMVECTOR VC2 = XMVectorMultiply(VC, VC); XMVECTOR T7 = XMVectorSplatW(TanCoefficients1.v); XMVECTOR T6 = XMVectorSplatZ(TanCoefficients1.v); XMVECTOR T4 = XMVectorSplatX(TanCoefficients1.v); XMVECTOR T3 = XMVectorSplatW(TanCoefficients0.v); XMVECTOR T5 = XMVectorSplatY(TanCoefficients1.v); XMVECTOR T2 = XMVectorSplatZ(TanCoefficients0.v); XMVECTOR T1 = XMVectorSplatY(TanCoefficients0.v); XMVECTOR T0 = XMVectorSplatX(TanCoefficients0.v); XMVECTOR VBIsEven = XMVectorAndInt(VB, Mask.v); VBIsEven = XMVectorEqualInt(VBIsEven, Zero); XMVECTOR N = XMVectorMultiplyAdd(VC2, T7, T6); XMVECTOR D = XMVectorMultiplyAdd(VC2, T4, T3); N = XMVectorMultiplyAdd(VC2, N, T5); D = XMVectorMultiplyAdd(VC2, D, T2); N = XMVectorMultiply(VC2, N); D = XMVectorMultiplyAdd(VC2, D, T1); N = XMVectorMultiplyAdd(VC, N, VC); XMVECTOR VCNearZero = XMVectorInBounds(VC, Epsilon); D = XMVectorMultiplyAdd(VC2, D, T0); N = XMVectorSelect(N, VC, VCNearZero); D = XMVectorSelect(D, g_XMOne.v, VCNearZero); XMVECTOR R0 = XMVectorNegate(N); XMVECTOR R1 = XMVectorDivide(N,D); R0 = XMVectorDivide(D,R0); XMVECTOR VIsZero = XMVectorEqual(V, Zero); XMVECTOR Result = XMVectorSelect(R0, R1, VBIsEven); Result = XMVectorSelect(Result, Zero, VIsZero); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSinH( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = sinhf( V.vector4_f32[0] ); Result.vector4_f32[1] = sinhf( V.vector4_f32[1] ); Result.vector4_f32[2] = sinhf( V.vector4_f32[2] ); Result.vector4_f32[3] = sinhf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Scale = {1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f}; // 1.0f / ln(2.0f) XMVECTOR V1 = vmlaq_f32( g_XMNegativeOne.v, V, Scale.v ); XMVECTOR V2 = vmlsq_f32( g_XMNegativeOne.v, V, Scale.v ); XMVECTOR E1 = XMVectorExp(V1); XMVECTOR E2 = XMVectorExp(V2); return vsubq_f32(E1, E2);#elif defined(_XM_SSE_INTRINSICS_) static const XMVECTORF32 Scale = {1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f}; // 1.0f / ln(2.0f) XMVECTOR V1 = _mm_mul_ps(V, Scale); V1 = _mm_add_ps(V1,g_XMNegativeOne); XMVECTOR V2 = _mm_mul_ps(V, Scale); V2 = _mm_sub_ps(g_XMNegativeOne,V2); XMVECTOR E1 = XMVectorExp(V1); XMVECTOR E2 = XMVectorExp(V2); return _mm_sub_ps(E1, E2);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorCosH( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = coshf( V.vector4_f32[0] ); Result.vector4_f32[1] = coshf( V.vector4_f32[1] ); Result.vector4_f32[2] = coshf( V.vector4_f32[2] ); Result.vector4_f32[3] = coshf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Scale = {1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f}; // 1.0f / ln(2.0f) XMVECTOR V1 = vmlaq_f32(g_XMNegativeOne.v, V, Scale.v); XMVECTOR V2 = vmlsq_f32(g_XMNegativeOne.v, V, Scale.v); XMVECTOR E1 = XMVectorExp(V1); XMVECTOR E2 = XMVectorExp(V2); return vaddq_f32(E1, E2);#elif defined(_XM_SSE_INTRINSICS_) static const XMVECTORF32 Scale = {1.442695040888963f, 1.442695040888963f, 1.442695040888963f, 1.442695040888963f}; // 1.0f / ln(2.0f) XMVECTOR V1 = _mm_mul_ps(V,Scale.v); V1 = _mm_add_ps(V1,g_XMNegativeOne.v); XMVECTOR V2 = _mm_mul_ps(V, Scale.v); V2 = _mm_sub_ps(g_XMNegativeOne.v,V2); XMVECTOR E1 = XMVectorExp(V1); XMVECTOR E2 = XMVectorExp(V2); return _mm_add_ps(E1, E2);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorTanH( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = tanhf( V.vector4_f32[0] ); Result.vector4_f32[1] = tanhf( V.vector4_f32[1] ); Result.vector4_f32[2] = tanhf( V.vector4_f32[2] ); Result.vector4_f32[3] = tanhf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Scale = {2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f}; // 2.0f / ln(2.0f) XMVECTOR E = vmulq_f32(V, Scale.v); E = XMVectorExp(E); E = vmlaq_f32( g_XMOneHalf.v, E, g_XMOneHalf.v ); E = XMVectorReciprocal(E); return vsubq_f32(g_XMOne.v, E);#elif defined(_XM_SSE_INTRINSICS_) static const XMVECTORF32 Scale = {2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f, 2.8853900817779268f}; // 2.0f / ln(2.0f) XMVECTOR E = _mm_mul_ps(V, Scale.v); E = XMVectorExp(E); E = _mm_mul_ps(E,g_XMOneHalf.v); E = _mm_add_ps(E,g_XMOneHalf.v); E = _mm_div_ps(g_XMOne.v,E); return _mm_sub_ps(g_XMOne.v,E);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorASin( FXMVECTOR V){ // 7-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarASin( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarASin( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarASin( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarASin( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 nonnegative = vcgeq_f32(V, g_XMZero); __n128 x = vabsq_f32(V); // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __n128 oneMValue = vsubq_f32(g_XMOne, x); __n128 clampOneMValue = vmaxq_f32(g_XMZero, oneMValue); __n128 root = XMVectorSqrt(clampOneMValue); // Compute polynomial approximation const XMVECTOR AC1 = g_XMArcCoefficients1; __n128 t0 = vdupq_lane_f32(vget_high_f32(AC1), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AC1), 0); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC1), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC1), 0); t0 = vmlaq_f32( vConstants, t0, x ); const XMVECTOR AC0 = g_XMArcCoefficients0; vConstants = vdupq_lane_f32(vget_high_f32(AC0), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_high_f32(AC0), 0); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC0), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC0), 0); t0 = vmlaq_f32( vConstants, t0, x ); t0 = vmulq_f32(t0, root); __n128 t1 = vsubq_f32(g_XMPi, t0); t0 = vbslq_f32( nonnegative, t0, t1 ); t0 = vsubq_f32(g_XMHalfPi, t0); return t0;#elif defined(_XM_SSE_INTRINSICS_) __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero); __m128 mvalue = _mm_sub_ps(g_XMZero, V); __m128 x = _mm_max_ps(V, mvalue); // |V| // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __m128 oneMValue = _mm_sub_ps(g_XMOne, x); __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue); __m128 root = _mm_sqrt_ps(clampOneMValue); // sqrt(1-|V|) // Compute polynomial approximation const XMVECTOR AC1 = g_XMArcCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 t0 = _mm_mul_ps(vConstants, x); vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(2, 2, 2, 2) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(1, 1, 1, 1) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(0, 0, 0, 0) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); const XMVECTOR AC0 = g_XMArcCoefficients0; vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(3, 3, 3, 3) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC0,_MM_SHUFFLE(2, 2, 2, 2) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(1, 1, 1, 1) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(0, 0, 0, 0) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, root); __m128 t1 = _mm_sub_ps(g_XMPi, t0); t0 = _mm_and_ps(nonnegative, t0); t1 = _mm_andnot_ps(nonnegative, t1); t0 = _mm_or_ps(t0, t1); t0 = _mm_sub_ps(g_XMHalfPi, t0); return t0;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorACos( FXMVECTOR V){ // 7-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarACos( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarACos( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarACos( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarACos( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 nonnegative = vcgeq_f32(V, g_XMZero); __n128 x = vabsq_f32(V); // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __n128 oneMValue = vsubq_f32(g_XMOne, x); __n128 clampOneMValue = vmaxq_f32(g_XMZero, oneMValue); __n128 root = XMVectorSqrt(clampOneMValue); // Compute polynomial approximation const XMVECTOR AC1 = g_XMArcCoefficients1; __n128 t0 = vdupq_lane_f32(vget_high_f32(AC1), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AC1), 0); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC1), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC1), 0); t0 = vmlaq_f32( vConstants, t0, x ); const XMVECTOR AC0 = g_XMArcCoefficients0; vConstants = vdupq_lane_f32(vget_high_f32(AC0), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_high_f32(AC0), 0); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC0), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AC0), 0); t0 = vmlaq_f32( vConstants, t0, x ); t0 = vmulq_f32(t0, root); __n128 t1 = vsubq_f32(g_XMPi, t0); t0 = vbslq_f32( nonnegative, t0, t1 ); return t0;#elif defined(_XM_SSE_INTRINSICS_) __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero); __m128 mvalue = _mm_sub_ps(g_XMZero, V); __m128 x = _mm_max_ps(V, mvalue); // |V| // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __m128 oneMValue = _mm_sub_ps(g_XMOne, x); __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue); __m128 root = _mm_sqrt_ps(clampOneMValue); // sqrt(1-|V|) // Compute polynomial approximation const XMVECTOR AC1 = g_XMArcCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 t0 = _mm_mul_ps(vConstants, x); vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(2, 2, 2, 2) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(1, 1, 1, 1) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC1, _MM_SHUFFLE(0, 0, 0, 0) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); const XMVECTOR AC0 = g_XMArcCoefficients0; vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(3, 3, 3, 3) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(2, 2, 2, 2) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(1, 1, 1, 1) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AC0, _MM_SHUFFLE(0, 0, 0, 0) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, root); __m128 t1 = _mm_sub_ps(g_XMPi, t0); t0 = _mm_and_ps(nonnegative, t0); t1 = _mm_andnot_ps(nonnegative, t1); t0 = _mm_or_ps(t0, t1); return t0;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorATan( FXMVECTOR V){ // 17-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = atanf( V.vector4_f32[0] ); Result.vector4_f32[1] = atanf( V.vector4_f32[1] ); Result.vector4_f32[2] = atanf( V.vector4_f32[2] ); Result.vector4_f32[3] = atanf( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 absV = vabsq_f32(V); __n128 invV = XMVectorReciprocal(V); __n128 comp = vcgtq_f32(V, g_XMOne); __n128 sign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne); comp = vcleq_f32(absV, g_XMOne); sign = vbslq_f32(comp, g_XMZero, sign); __n128 x = vbslq_f32(comp, V, invV); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation const XMVECTOR TC1 = g_XMATanCoefficients1; __n128 Result = vdupq_lane_f32(vget_high_f32(TC1), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(TC1), 0); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_low_f32(TC1), 1); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_low_f32(TC1), 0); Result = vmlaq_f32( vConstants, Result, x2 ); const XMVECTOR TC0 = g_XMATanCoefficients0; vConstants = vdupq_lane_f32(vget_high_f32(TC0), 1); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_high_f32(TC0), 0); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_low_f32(TC0), 1); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_low_f32(TC0), 0); Result = vmlaq_f32( vConstants, Result, x2 ); Result = vmlaq_f32( g_XMOne, Result, x2 ); Result = vmulq_f32( Result, x ); __n128 result1 = vmulq_f32(sign, g_XMHalfPi); result1 = vsubq_f32(result1, Result); comp = vceqq_f32(sign, g_XMZero); Result = vbslq_f32( comp, Result, result1 ); return Result;#elif defined(_XM_SSE_INTRINSICS_) __m128 absV = XMVectorAbs(V); __m128 invV = _mm_div_ps(g_XMOne, V); __m128 comp = _mm_cmpgt_ps(V, g_XMOne); __m128 select0 = _mm_and_ps(comp, g_XMOne); __m128 select1 = _mm_andnot_ps(comp, g_XMNegativeOne); __m128 sign = _mm_or_ps(select0, select1); comp = _mm_cmple_ps(absV, g_XMOne); select0 = _mm_and_ps(comp, g_XMZero); select1 = _mm_andnot_ps(comp, sign); sign = _mm_or_ps(select0, select1); select0 = _mm_and_ps(comp, V); select1 = _mm_andnot_ps(comp, invV); __m128 x = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation const XMVECTOR TC1 = g_XMATanCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( TC1, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 Result = _mm_mul_ps(vConstants, x2); vConstants = XM_PERMUTE_PS( TC1, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( TC1, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( TC1, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); const XMVECTOR TC0 = g_XMATanCoefficients0; vConstants = XM_PERMUTE_PS( TC0, _MM_SHUFFLE(3, 3, 3, 3) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( TC0, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( TC0, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( TC0, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, x); __m128 result1 = _mm_mul_ps(sign, g_XMHalfPi); result1 = _mm_sub_ps(result1, Result); comp = _mm_cmpeq_ps(sign, g_XMZero); select0 = _mm_and_ps(comp, Result); select1 = _mm_andnot_ps(comp, result1); Result = _mm_or_ps(select0, select1); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorATan2( FXMVECTOR Y, FXMVECTOR X){ // Return the inverse tangent of Y / X in the range of -Pi to Pi with the following exceptions: // Y == 0 and X is Negative -> Pi with the sign of Y // y == 0 and x is positive -> 0 with the sign of y // Y != 0 and X == 0 -> Pi / 2 with the sign of Y // Y != 0 and X is Negative -> atan(y/x) + (PI with the sign of Y) // X == -Infinity and Finite Y -> Pi with the sign of Y // X == +Infinity and Finite Y -> 0 with the sign of Y // Y == Infinity and X is Finite -> Pi / 2 with the sign of Y // Y == Infinity and X == -Infinity -> 3Pi / 4 with the sign of Y // Y == Infinity and X == +Infinity -> Pi / 4 with the sign of Y static const XMVECTORF32 ATan2Constants = {XM_PI, XM_PIDIV2, XM_PIDIV4, XM_PI * 3.0f / 4.0f}; XMVECTOR Zero = XMVectorZero(); XMVECTOR ATanResultValid = XMVectorTrueInt(); XMVECTOR Pi = XMVectorSplatX(ATan2Constants); XMVECTOR PiOverTwo = XMVectorSplatY(ATan2Constants); XMVECTOR PiOverFour = XMVectorSplatZ(ATan2Constants); XMVECTOR ThreePiOverFour = XMVectorSplatW(ATan2Constants); XMVECTOR YEqualsZero = XMVectorEqual(Y, Zero); XMVECTOR XEqualsZero = XMVectorEqual(X, Zero); XMVECTOR XIsPositive = XMVectorAndInt(X, g_XMNegativeZero.v); XIsPositive = XMVectorEqualInt(XIsPositive, Zero); XMVECTOR YEqualsInfinity = XMVectorIsInfinite(Y); XMVECTOR XEqualsInfinity = XMVectorIsInfinite(X); XMVECTOR YSign = XMVectorAndInt(Y, g_XMNegativeZero.v); Pi = XMVectorOrInt(Pi, YSign); PiOverTwo = XMVectorOrInt(PiOverTwo, YSign); PiOverFour = XMVectorOrInt(PiOverFour, YSign); ThreePiOverFour = XMVectorOrInt(ThreePiOverFour, YSign); XMVECTOR R1 = XMVectorSelect(Pi, YSign, XIsPositive); XMVECTOR R2 = XMVectorSelect(ATanResultValid, PiOverTwo, XEqualsZero); XMVECTOR R3 = XMVectorSelect(R2, R1, YEqualsZero); XMVECTOR R4 = XMVectorSelect(ThreePiOverFour, PiOverFour, XIsPositive); XMVECTOR R5 = XMVectorSelect(PiOverTwo, R4, XEqualsInfinity); XMVECTOR Result = XMVectorSelect(R3, R5, YEqualsInfinity); ATanResultValid = XMVectorEqualInt(Result, ATanResultValid); XMVECTOR V = XMVectorDivide(Y, X); XMVECTOR R0 = XMVectorATan(V); R1 = XMVectorSelect( Pi, Zero, XIsPositive ); R2 = XMVectorAdd(R0, R1); return XMVectorSelect(Result, R2, ATanResultValid);}//------------------------------------------------------------------------------inline XMVECTOR XMVectorSinEst( FXMVECTOR V){ // 7-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarSinEst( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarSinEst( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarSinEst( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarSinEst( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with sin(y) = sin(x). __n128 sign = vandq_u32(x, g_XMNegativeZero); __n128 c = vorrq_u32(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __n128 absx = vabsq_f32( x ); __n128 rflx = vsubq_f32(c, x); __n128 comp = vcleq_f32(absx, g_XMHalfPi); x = vbslq_f32( comp, x, rflx ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation const XMVECTOR SEC = g_XMSinCoefficients1; XMVECTOR Result = vdupq_lane_f32(vget_high_f32(SEC), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SEC), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(SEC), 1); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); Result = vmulq_f32(Result, x); return Result;#elif defined(_XM_SSE_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with sin(y) = sin(x). __m128 sign = _mm_and_ps(x, g_XMNegativeZero); __m128 c = _mm_or_ps(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __m128 absx = _mm_andnot_ps(sign, x); // |x| __m128 rflx = _mm_sub_ps(c, x); __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi); __m128 select0 = _mm_and_ps(comp, x); __m128 select1 = _mm_andnot_ps(comp, rflx); x = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation const XMVECTOR SEC = g_XMSinCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( SEC, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 Result = _mm_mul_ps(vConstants, x2); vConstants = XM_PERMUTE_PS( SEC, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SEC, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, x); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorCosEst( FXMVECTOR V){ // 6-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarCosEst( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarCosEst( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarCosEst( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarCosEst( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Map V to x in [-pi,pi]. XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x). __n128 sign = vandq_u32(x, g_XMNegativeZero); __n128 c = vorrq_u32(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __n128 absx = vabsq_f32( x ); __n128 rflx = vsubq_f32(c, x); __n128 comp = vcleq_f32(absx, g_XMHalfPi); x = vbslq_f32( comp, x, rflx ); sign = vbslq_f32( comp, g_XMOne, g_XMNegativeOne ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation const XMVECTOR CEC = g_XMCosCoefficients1; XMVECTOR Result = vdupq_lane_f32(vget_high_f32(CEC), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(CEC), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(CEC), 1); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); Result = vmulq_f32(Result, sign); return Result;#elif defined(_XM_SSE_INTRINSICS_) // Map V to x in [-pi,pi]. XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x). XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero); __m128 c = _mm_or_ps(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __m128 absx = _mm_andnot_ps(sign, x); // |x| __m128 rflx = _mm_sub_ps(c, x); __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi); __m128 select0 = _mm_and_ps(comp, x); __m128 select1 = _mm_andnot_ps(comp, rflx); x = _mm_or_ps(select0, select1); select0 = _mm_and_ps(comp, g_XMOne); select1 = _mm_andnot_ps(comp, g_XMNegativeOne); sign = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation const XMVECTOR CEC = g_XMCosCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( CEC, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 Result = _mm_mul_ps(vConstants, x2); vConstants = XM_PERMUTE_PS( CEC, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CEC, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, sign); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline void XMVectorSinCosEst( XMVECTOR* pSin, XMVECTOR* pCos, FXMVECTOR V){ assert(pSin != NULL); assert(pCos != NULL); // 7/6-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Sin; XMVECTOR Cos; XMScalarSinCosEst(&Sin.vector4_f32[0], &Cos.vector4_f32[0], V.vector4_f32[0]); XMScalarSinCosEst(&Sin.vector4_f32[1], &Cos.vector4_f32[1], V.vector4_f32[1]); XMScalarSinCosEst(&Sin.vector4_f32[2], &Cos.vector4_f32[2], V.vector4_f32[2]); XMScalarSinCosEst(&Sin.vector4_f32[3], &Cos.vector4_f32[3], V.vector4_f32[3]); *pSin = Sin; *pCos = Cos;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with cos(y) = sign*cos(x). __n128 sign = vandq_u32(x, g_XMNegativeZero); __n128 c = vorrq_u32(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __n128 absx = vabsq_f32( x ); __n128 rflx = vsubq_f32(c, x); __n128 comp = vcleq_f32(absx, g_XMHalfPi); x = vbslq_f32( comp, x, rflx ); sign = vbslq_f32( comp, g_XMOne, g_XMNegativeOne ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation for sine const XMVECTOR SEC = g_XMSinCoefficients1; XMVECTOR Result = vdupq_lane_f32(vget_high_f32(SEC), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(SEC), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(SEC), 1); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); *pSin = vmulq_f32(Result, x); // Compute polynomial approximation const XMVECTOR CEC = g_XMCosCoefficients1; Result = vdupq_lane_f32(vget_high_f32(CEC), 1); vConstants = vdupq_lane_f32(vget_high_f32(CEC), 0); Result = vmlaq_f32(vConstants, Result, x2); vConstants = vdupq_lane_f32(vget_low_f32(CEC), 1); Result = vmlaq_f32(vConstants, Result, x2); Result = vmlaq_f32(g_XMOne, Result, x2); *pCos = vmulq_f32(Result, sign);#elif defined(_XM_SSE_INTRINSICS_) // Force the value within the bounds of pi XMVECTOR x = XMVectorModAngles(V); // Map in [-pi/2,pi/2] with sin(y) = sin(x), cos(y) = sign*cos(x). XMVECTOR sign = _mm_and_ps(x, g_XMNegativeZero); __m128 c = _mm_or_ps(g_XMPi, sign); // pi when x >= 0, -pi when x < 0 __m128 absx = _mm_andnot_ps(sign, x); // |x| __m128 rflx = _mm_sub_ps(c, x); __m128 comp = _mm_cmple_ps(absx, g_XMHalfPi); __m128 select0 = _mm_and_ps(comp, x); __m128 select1 = _mm_andnot_ps(comp, rflx); x = _mm_or_ps(select0, select1); select0 = _mm_and_ps(comp, g_XMOne); select1 = _mm_andnot_ps(comp, g_XMNegativeOne); sign = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation for sine const XMVECTOR SEC = g_XMSinCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( SEC, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 Result = _mm_mul_ps(vConstants, x2); vConstants = XM_PERMUTE_PS( SEC, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( SEC, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, x); *pSin = Result; // Compute polynomial approximation for cosine const XMVECTOR CEC = g_XMCosCoefficients1; vConstants = XM_PERMUTE_PS( CEC, _MM_SHUFFLE(3, 3, 3, 3) ); Result = _mm_mul_ps(vConstants, x2); vConstants = XM_PERMUTE_PS( CEC, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( CEC, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); Result = _mm_add_ps(Result, g_XMOne); Result = _mm_mul_ps(Result, sign); *pCos = Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorTanEst( FXMVECTOR V){ XMVECTOR OneOverPi = XMVectorSplatW(g_XMTanEstCoefficients.v); XMVECTOR V1 = XMVectorMultiply(V, OneOverPi); V1 = XMVectorRound(V1); V1 = XMVectorNegativeMultiplySubtract(g_XMPi.v, V1, V); XMVECTOR T0 = XMVectorSplatX(g_XMTanEstCoefficients.v); XMVECTOR T1 = XMVectorSplatY(g_XMTanEstCoefficients.v); XMVECTOR T2 = XMVectorSplatZ(g_XMTanEstCoefficients.v); XMVECTOR V2T2 = XMVectorNegativeMultiplySubtract(V1, V1, T2); XMVECTOR V2 = XMVectorMultiply(V1, V1); XMVECTOR V1T0 = XMVectorMultiply(V1, T0); XMVECTOR V1T1 = XMVectorMultiply(V1, T1); XMVECTOR D = XMVectorReciprocalEst(V2T2); XMVECTOR N = XMVectorMultiplyAdd(V2, V1T1, V1T0); return XMVectorMultiply(N, D);}//------------------------------------------------------------------------------inline XMVECTOR XMVectorASinEst( FXMVECTOR V){ // 3-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarASinEst( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarASinEst( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarASinEst( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarASinEst( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 nonnegative = vcgeq_f32(V, g_XMZero); __n128 x = vabsq_f32(V); // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __n128 oneMValue = vsubq_f32(g_XMOne, x); __n128 clampOneMValue = vmaxq_f32(g_XMZero, oneMValue); __n128 root = XMVectorSqrt(clampOneMValue); // Compute polynomial approximation const XMVECTOR AEC = g_XMArcEstCoefficients; __n128 t0 = vdupq_lane_f32(vget_high_f32(AEC), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AEC), 0); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AEC), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AEC), 0); t0 = vmlaq_f32( vConstants, t0, x ); t0 = vmulq_f32(t0, root); __n128 t1 = vsubq_f32(g_XMPi, t0); t0 = vbslq_f32( nonnegative, t0, t1 ); t0 = vsubq_f32(g_XMHalfPi, t0); return t0;#elif defined(_XM_SSE_INTRINSICS_) __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero); __m128 mvalue = _mm_sub_ps(g_XMZero, V); __m128 x = _mm_max_ps(V, mvalue); // |V| // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __m128 oneMValue = _mm_sub_ps(g_XMOne, x); __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue); __m128 root = _mm_sqrt_ps(clampOneMValue); // sqrt(1-|V|) // Compute polynomial approximation const XMVECTOR AEC = g_XMArcEstCoefficients; XMVECTOR vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 t0 = _mm_mul_ps(vConstants, x); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(2, 2, 2, 2) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(1, 1, 1, 1) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(0, 0, 0, 0) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, root); __m128 t1 = _mm_sub_ps(g_XMPi, t0); t0 = _mm_and_ps(nonnegative, t0); t1 = _mm_andnot_ps(nonnegative, t1); t0 = _mm_or_ps(t0, t1); t0 = _mm_sub_ps(g_XMHalfPi, t0); return t0;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorACosEst( FXMVECTOR V){ // 3-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = XMScalarACosEst( V.vector4_f32[0] ); Result.vector4_f32[1] = XMScalarACosEst( V.vector4_f32[1] ); Result.vector4_f32[2] = XMScalarACosEst( V.vector4_f32[2] ); Result.vector4_f32[3] = XMScalarACosEst( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 nonnegative = vcgeq_f32(V, g_XMZero); __n128 x = vabsq_f32(V); // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __n128 oneMValue = vsubq_f32(g_XMOne, x); __n128 clampOneMValue = vmaxq_f32(g_XMZero, oneMValue); __n128 root = XMVectorSqrt(clampOneMValue); // Compute polynomial approximation const XMVECTOR AEC = g_XMArcEstCoefficients; __n128 t0 = vdupq_lane_f32(vget_high_f32(AEC), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AEC), 0); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AEC), 1); t0 = vmlaq_f32( vConstants, t0, x ); vConstants = vdupq_lane_f32(vget_low_f32(AEC), 0); t0 = vmlaq_f32( vConstants, t0, x ); t0 = vmulq_f32(t0, root); __n128 t1 = vsubq_f32(g_XMPi, t0); t0 = vbslq_f32( nonnegative, t0, t1 ); return t0;#elif defined(_XM_SSE_INTRINSICS_) __m128 nonnegative = _mm_cmpge_ps(V, g_XMZero); __m128 mvalue = _mm_sub_ps(g_XMZero, V); __m128 x = _mm_max_ps(V, mvalue); // |V| // Compute (1-|V|), clamp to zero to avoid sqrt of negative number. __m128 oneMValue = _mm_sub_ps(g_XMOne, x); __m128 clampOneMValue = _mm_max_ps(g_XMZero, oneMValue); __m128 root = _mm_sqrt_ps(clampOneMValue); // sqrt(1-|V|) // Compute polynomial approximation const XMVECTOR AEC = g_XMArcEstCoefficients; XMVECTOR vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 t0 = _mm_mul_ps(vConstants, x); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(2, 2, 2, 2) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(1, 1, 1, 1) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, x); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(0, 0, 0, 0) ); t0 = _mm_add_ps(t0, vConstants); t0 = _mm_mul_ps(t0, root); __m128 t1 = _mm_sub_ps(g_XMPi, t0); t0 = _mm_and_ps(nonnegative, t0); t1 = _mm_andnot_ps(nonnegative, t1); t0 = _mm_or_ps(t0, t1); return t0;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------namespace Internal{inline float XMScalarATanEst( float Value){ float y, sign; if (fabsf(Value) <= 1.0f) { y = Value; sign = 0.0f; } else if (Value > 1.0f) { y = 1.0f / Value; sign = 1.0f; } else { y = 1.0f / Value; sign = -1.0f; } // 9-degree minimax approximation float y2 = y*y; float poly = ((((0.0208351f*y2-0.085133f)*y2+0.180141f)*y2-0.3302995f)*y2+0.999866f)*y; return (sign == 0.0f ? poly : sign*XM_PIDIV2 - poly);}}; // namespace Internal//------------------------------------------------------------------------------inline XMVECTOR XMVectorATanEst( FXMVECTOR V){ // 9-degree minimax approximation#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = Internal::XMScalarATanEst( V.vector4_f32[0] ); Result.vector4_f32[1] = Internal::XMScalarATanEst( V.vector4_f32[1] ); Result.vector4_f32[2] = Internal::XMScalarATanEst( V.vector4_f32[2] ); Result.vector4_f32[3] = Internal::XMScalarATanEst( V.vector4_f32[3] ); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 absV = vabsq_f32(V); __n128 invV = XMVectorReciprocalEst(V); __n128 comp = vcgtq_f32(V, g_XMOne); __n128 sign = vbslq_f32(comp, g_XMOne, g_XMNegativeOne ); comp = vcleq_f32(absV, g_XMOne); sign = vbslq_f32(comp, g_XMZero, sign ); __n128 x = vbslq_f32(comp, V, invV ); __n128 x2 = vmulq_f32(x, x); // Compute polynomial approximation const XMVECTOR AEC = g_XMATanEstCoefficients1; __n128 Result = vdupq_lane_f32(vget_high_f32(AEC), 1); XMVECTOR vConstants = vdupq_lane_f32(vget_high_f32(AEC), 0); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_low_f32(AEC), 1); Result = vmlaq_f32( vConstants, Result, x2 ); vConstants = vdupq_lane_f32(vget_low_f32( AEC), 0); Result = vmlaq_f32( vConstants, Result, x2 ); // ATanEstCoefficients0 is already splatted Result = vmlaq_f32( g_XMATanEstCoefficients0, Result, x2 ); Result = vmulq_f32( Result, x ); float32x4_t result1 = vmulq_f32(sign, g_XMHalfPi); result1 = vsubq_f32(result1, Result); comp = vceqq_f32(sign, g_XMZero); Result = vbslq_f32( comp, Result, result1 ); return Result;#elif defined(_XM_SSE_INTRINSICS_) __m128 absV = XMVectorAbs(V); __m128 invV = _mm_div_ps(g_XMOne, V); __m128 comp = _mm_cmpgt_ps(V, g_XMOne); __m128 select0 = _mm_and_ps(comp, g_XMOne); __m128 select1 = _mm_andnot_ps(comp, g_XMNegativeOne); __m128 sign = _mm_or_ps(select0, select1); comp = _mm_cmple_ps(absV, g_XMOne); select0 = _mm_and_ps(comp, g_XMZero); select1 = _mm_andnot_ps(comp, sign); sign = _mm_or_ps(select0, select1); select0 = _mm_and_ps(comp, V); select1 = _mm_andnot_ps(comp, invV); __m128 x = _mm_or_ps(select0, select1); __m128 x2 = _mm_mul_ps(x, x); // Compute polynomial approximation const XMVECTOR AEC = g_XMATanEstCoefficients1; XMVECTOR vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(3, 3, 3, 3) ); __m128 Result = _mm_mul_ps(vConstants, x2); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(2, 2, 2, 2) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(1, 1, 1, 1) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); vConstants = XM_PERMUTE_PS( AEC, _MM_SHUFFLE(0, 0, 0, 0) ); Result = _mm_add_ps(Result, vConstants); Result = _mm_mul_ps(Result, x2); // ATanEstCoefficients0 is already splatted Result = _mm_add_ps(Result, g_XMATanEstCoefficients0); Result = _mm_mul_ps(Result, x); __m128 result1 = _mm_mul_ps(sign, g_XMHalfPi); result1 = _mm_sub_ps(result1, Result); comp = _mm_cmpeq_ps(sign, g_XMZero); select0 = _mm_and_ps(comp, Result); select1 = _mm_andnot_ps(comp, result1); Result = _mm_or_ps(select0, select1); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorATan2Est( FXMVECTOR Y, FXMVECTOR X){ static const XMVECTORF32 ATan2Constants = {XM_PI, XM_PIDIV2, XM_PIDIV4, 2.3561944905f /* Pi*3/4 */}; const XMVECTOR Zero = XMVectorZero(); XMVECTOR ATanResultValid = XMVectorTrueInt(); XMVECTOR Pi = XMVectorSplatX(ATan2Constants); XMVECTOR PiOverTwo = XMVectorSplatY(ATan2Constants); XMVECTOR PiOverFour = XMVectorSplatZ(ATan2Constants); XMVECTOR ThreePiOverFour = XMVectorSplatW(ATan2Constants); XMVECTOR YEqualsZero = XMVectorEqual(Y, Zero); XMVECTOR XEqualsZero = XMVectorEqual(X, Zero); XMVECTOR XIsPositive = XMVectorAndInt(X, g_XMNegativeZero.v); XIsPositive = XMVectorEqualInt(XIsPositive, Zero); XMVECTOR YEqualsInfinity = XMVectorIsInfinite(Y); XMVECTOR XEqualsInfinity = XMVectorIsInfinite(X); XMVECTOR YSign = XMVectorAndInt(Y, g_XMNegativeZero.v); Pi = XMVectorOrInt(Pi, YSign); PiOverTwo = XMVectorOrInt(PiOverTwo, YSign); PiOverFour = XMVectorOrInt(PiOverFour, YSign); ThreePiOverFour = XMVectorOrInt(ThreePiOverFour, YSign); XMVECTOR R1 = XMVectorSelect(Pi, YSign, XIsPositive); XMVECTOR R2 = XMVectorSelect(ATanResultValid, PiOverTwo, XEqualsZero); XMVECTOR R3 = XMVectorSelect(R2, R1, YEqualsZero); XMVECTOR R4 = XMVectorSelect(ThreePiOverFour, PiOverFour, XIsPositive); XMVECTOR R5 = XMVectorSelect(PiOverTwo, R4, XEqualsInfinity); XMVECTOR Result = XMVectorSelect(R3, R5, YEqualsInfinity); ATanResultValid = XMVectorEqualInt(Result, ATanResultValid); XMVECTOR Reciprocal = XMVectorReciprocalEst(X); XMVECTOR V = XMVectorMultiply(Y, Reciprocal); XMVECTOR R0 = XMVectorATanEst(V); R1 = XMVectorSelect( Pi, Zero, XIsPositive ); R2 = XMVectorAdd(R0, R1); Result = XMVectorSelect(Result, R2, ATanResultValid); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVectorLerp( FXMVECTOR V0, FXMVECTOR V1, float t){ // V0 + t * (V1 - V0)#if defined(_XM_NO_INTRINSICS_) XMVECTOR Scale = XMVectorReplicate(t); XMVECTOR Length = XMVectorSubtract(V1, V0); return XMVectorMultiplyAdd(Length, Scale, V0);#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR L = vsubq_f32( V1, V0 ); return vmlaq_n_f32( V0, L, t );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR L = _mm_sub_ps( V1, V0 ); XMVECTOR S = _mm_set_ps1( t ); XMVECTOR Result = _mm_mul_ps( L, S ); return _mm_add_ps( Result, V0 );#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorLerpV( FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR T){ // V0 + T * (V1 - V0)#if defined(_XM_NO_INTRINSICS_) XMVECTOR Length = XMVectorSubtract(V1, V0); return XMVectorMultiplyAdd(Length, T, V0);#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR L = vsubq_f32( V1, V0 ); return vmlaq_f32( V0, L, T );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR Length = _mm_sub_ps( V1, V0 ); XMVECTOR Result = _mm_mul_ps( Length, T ); return _mm_add_ps( Result, V0 );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorHermite( FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, GXMVECTOR Tangent1, float t){ // Result = (2 * t^3 - 3 * t^2 + 1) * Position0 + // (t^3 - 2 * t^2 + t) * Tangent0 + // (-2 * t^3 + 3 * t^2) * Position1 + // (t^3 - t^2) * Tangent1#if defined(_XM_NO_INTRINSICS_) float t2 = t * t; float t3 = t * t2; XMVECTOR P0 = XMVectorReplicate(2.0f * t3 - 3.0f * t2 + 1.0f); XMVECTOR T0 = XMVectorReplicate(t3 - 2.0f * t2 + t); XMVECTOR P1 = XMVectorReplicate(-2.0f * t3 + 3.0f * t2); XMVECTOR T1 = XMVectorReplicate(t3 - t2); XMVECTOR Result = XMVectorMultiply(P0, Position0); Result = XMVectorMultiplyAdd(T0, Tangent0, Result); Result = XMVectorMultiplyAdd(P1, Position1, Result); Result = XMVectorMultiplyAdd(T1, Tangent1, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) float t2 = t * t; float t3 = t * t2; XMVECTOR P0 = vdupq_n_f32(2.0f * t3 - 3.0f * t2 + 1.0f); XMVECTOR T0 = vdupq_n_f32(t3 - 2.0f * t2 + t); XMVECTOR P1 = vdupq_n_f32(-2.0f * t3 + 3.0f * t2); XMVECTOR T1 = vdupq_n_f32(t3 - t2); XMVECTOR vResult = vmulq_f32(P0, Position0); vResult = vmlaq_f32( vResult, T0, Tangent0 ); vResult = vmlaq_f32( vResult, P1, Position1 ); vResult = vmlaq_f32( vResult, T1, Tangent1 ); return vResult;#elif defined(_XM_SSE_INTRINSICS_) float t2 = t * t; float t3 = t * t2; XMVECTOR P0 = _mm_set_ps1(2.0f * t3 - 3.0f * t2 + 1.0f); XMVECTOR T0 = _mm_set_ps1(t3 - 2.0f * t2 + t); XMVECTOR P1 = _mm_set_ps1(-2.0f * t3 + 3.0f * t2); XMVECTOR T1 = _mm_set_ps1(t3 - t2); XMVECTOR vResult = _mm_mul_ps(P0, Position0); XMVECTOR vTemp = _mm_mul_ps(T0, Tangent0); vResult = _mm_add_ps(vResult,vTemp); vTemp = _mm_mul_ps(P1, Position1); vResult = _mm_add_ps(vResult,vTemp); vTemp = _mm_mul_ps(T1, Tangent1); vResult = _mm_add_ps(vResult,vTemp); return vResult;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorHermiteV( FXMVECTOR Position0, FXMVECTOR Tangent0, FXMVECTOR Position1, GXMVECTOR Tangent1, CXMVECTOR T){ // Result = (2 * t^3 - 3 * t^2 + 1) * Position0 + // (t^3 - 2 * t^2 + t) * Tangent0 + // (-2 * t^3 + 3 * t^2) * Position1 + // (t^3 - t^2) * Tangent1#if defined(_XM_NO_INTRINSICS_) XMVECTOR T2 = XMVectorMultiply(T, T); XMVECTOR T3 = XMVectorMultiply(T , T2); XMVECTOR P0 = XMVectorReplicate(2.0f * T3.vector4_f32[0] - 3.0f * T2.vector4_f32[0] + 1.0f); XMVECTOR T0 = XMVectorReplicate(T3.vector4_f32[1] - 2.0f * T2.vector4_f32[1] + T.vector4_f32[1]); XMVECTOR P1 = XMVectorReplicate(-2.0f * T3.vector4_f32[2] + 3.0f * T2.vector4_f32[2]); XMVECTOR T1 = XMVectorReplicate(T3.vector4_f32[3] - T2.vector4_f32[3]); XMVECTOR Result = XMVectorMultiply(P0, Position0); Result = XMVectorMultiplyAdd(T0, Tangent0, Result); Result = XMVectorMultiplyAdd(P1, Position1, Result); Result = XMVectorMultiplyAdd(T1, Tangent1, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 CatMulT2 = {-3.0f,-2.0f,3.0f,-1.0f}; static const XMVECTORF32 CatMulT3 = {2.0f,1.0f,-2.0f,1.0f}; XMVECTOR T2 = vmulq_f32(T,T); XMVECTOR T3 = vmulq_f32(T,T2); // Mul by the constants against t^2 T2 = vmulq_f32(T2,CatMulT2); // Mul by the constants against t^3 T3 = vmlaq_f32(T2, T3, CatMulT3 ); // T3 now has the pre-result. // I need to add t.y only T2 = vandq_u32(T,g_XMMaskY); T3 = vaddq_f32(T3,T2); // Add 1.0f to x T3 = vaddq_f32(T3,g_XMIdentityR0); // Now, I have the constants created // Mul the x constant to Position0 XMVECTOR vResult = vdupq_lane_f32( vget_low_f32( T3 ), 0 ); // T3[0] vResult = vmulq_f32(vResult,Position0); // Mul the y constant to Tangent0 T2 = vdupq_lane_f32( vget_low_f32( T3 ), 1 ); // T3[1] vResult = vmlaq_f32(vResult, T2, Tangent0 ); // Mul the z constant to Position1 T2 = vdupq_lane_f32( vget_high_f32( T3 ), 0 ); // T3[2] vResult = vmlaq_f32(vResult, T2, Position1 ); // Mul the w constant to Tangent1 T3 = vdupq_lane_f32( vget_high_f32( T3 ), 1 ); // T3[3] vResult = vmlaq_f32(vResult, T3, Tangent1 ); return vResult;#elif defined(_XM_SSE_INTRINSICS_) static const XMVECTORF32 CatMulT2 = {-3.0f,-2.0f,3.0f,-1.0f}; static const XMVECTORF32 CatMulT3 = {2.0f,1.0f,-2.0f,1.0f}; XMVECTOR T2 = _mm_mul_ps(T,T); XMVECTOR T3 = _mm_mul_ps(T,T2); // Mul by the constants against t^2 T2 = _mm_mul_ps(T2,CatMulT2); // Mul by the constants against t^3 T3 = _mm_mul_ps(T3,CatMulT3); // T3 now has the pre-result. T3 = _mm_add_ps(T3,T2); // I need to add t.y only T2 = _mm_and_ps(T,g_XMMaskY); T3 = _mm_add_ps(T3,T2); // Add 1.0f to x T3 = _mm_add_ps(T3,g_XMIdentityR0); // Now, I have the constants created // Mul the x constant to Position0 XMVECTOR vResult = XM_PERMUTE_PS(T3,_MM_SHUFFLE(0,0,0,0)); vResult = _mm_mul_ps(vResult,Position0); // Mul the y constant to Tangent0 T2 = XM_PERMUTE_PS(T3,_MM_SHUFFLE(1,1,1,1)); T2 = _mm_mul_ps(T2,Tangent0); vResult = _mm_add_ps(vResult,T2); // Mul the z constant to Position1 T2 = XM_PERMUTE_PS(T3,_MM_SHUFFLE(2,2,2,2)); T2 = _mm_mul_ps(T2,Position1); vResult = _mm_add_ps(vResult,T2); // Mul the w constant to Tangent1 T3 = XM_PERMUTE_PS(T3,_MM_SHUFFLE(3,3,3,3)); T3 = _mm_mul_ps(T3,Tangent1); vResult = _mm_add_ps(vResult,T3); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorCatmullRom( FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, GXMVECTOR Position3, float t){ // Result = ((-t^3 + 2 * t^2 - t) * Position0 + // (3 * t^3 - 5 * t^2 + 2) * Position1 + // (-3 * t^3 + 4 * t^2 + t) * Position2 + // (t^3 - t^2) * Position3) * 0.5#if defined(_XM_NO_INTRINSICS_) float t2 = t * t; float t3 = t * t2; XMVECTOR P0 = XMVectorReplicate((-t3 + 2.0f * t2 - t) * 0.5f); XMVECTOR P1 = XMVectorReplicate((3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f); XMVECTOR P2 = XMVectorReplicate((-3.0f * t3 + 4.0f * t2 + t) * 0.5f); XMVECTOR P3 = XMVectorReplicate((t3 - t2) * 0.5f); XMVECTOR Result = XMVectorMultiply(P0, Position0); Result = XMVectorMultiplyAdd(P1, Position1, Result); Result = XMVectorMultiplyAdd(P2, Position2, Result); Result = XMVectorMultiplyAdd(P3, Position3, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) float t2 = t * t; float t3 = t * t2; XMVECTOR P0 = vdupq_n_f32((-t3 + 2.0f * t2 - t) * 0.5f); XMVECTOR P1 = vdupq_n_f32((3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f); XMVECTOR P2 = vdupq_n_f32((-3.0f * t3 + 4.0f * t2 + t) * 0.5f); XMVECTOR P3 = vdupq_n_f32((t3 - t2) * 0.5f); P1 = vmulq_f32(P1, Position1); P0 = vmlaq_f32(P1, P0, Position0); P3 = vmulq_f32(P3, Position3); P2 = vmlaq_f32(P3, P2, Position2); P0 = vaddq_f32(P0,P2); return P0;#elif defined(_XM_SSE_INTRINSICS_) float t2 = t * t; float t3 = t * t2; XMVECTOR P0 = _mm_set_ps1((-t3 + 2.0f * t2 - t) * 0.5f); XMVECTOR P1 = _mm_set_ps1((3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f); XMVECTOR P2 = _mm_set_ps1((-3.0f * t3 + 4.0f * t2 + t) * 0.5f); XMVECTOR P3 = _mm_set_ps1((t3 - t2) * 0.5f); P0 = _mm_mul_ps(P0, Position0); P1 = _mm_mul_ps(P1, Position1); P2 = _mm_mul_ps(P2, Position2); P3 = _mm_mul_ps(P3, Position3); P0 = _mm_add_ps(P0,P1); P2 = _mm_add_ps(P2,P3); P0 = _mm_add_ps(P0,P2); return P0;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorCatmullRomV( FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, GXMVECTOR Position3, CXMVECTOR T){#if defined(_XM_NO_INTRINSICS_) float fx = T.vector4_f32[0]; float fy = T.vector4_f32[1]; float fz = T.vector4_f32[2]; float fw = T.vector4_f32[3]; XMVECTOR vResult = { 0.5f*((-fx*fx*fx+2*fx*fx-fx)*Position0.vector4_f32[0]+ (3*fx*fx*fx-5*fx*fx+2)*Position1.vector4_f32[0]+ (-3*fx*fx*fx+4*fx*fx+fx)*Position2.vector4_f32[0]+ (fx*fx*fx-fx*fx)*Position3.vector4_f32[0]), 0.5f*((-fy*fy*fy+2*fy*fy-fy)*Position0.vector4_f32[1]+ (3*fy*fy*fy-5*fy*fy+2)*Position1.vector4_f32[1]+ (-3*fy*fy*fy+4*fy*fy+fy)*Position2.vector4_f32[1]+ (fy*fy*fy-fy*fy)*Position3.vector4_f32[1]), 0.5f*((-fz*fz*fz+2*fz*fz-fz)*Position0.vector4_f32[2]+ (3*fz*fz*fz-5*fz*fz+2)*Position1.vector4_f32[2]+ (-3*fz*fz*fz+4*fz*fz+fz)*Position2.vector4_f32[2]+ (fz*fz*fz-fz*fz)*Position3.vector4_f32[2]), 0.5f*((-fw*fw*fw+2*fw*fw-fw)*Position0.vector4_f32[3]+ (3*fw*fw*fw-5*fw*fw+2)*Position1.vector4_f32[3]+ (-3*fw*fw*fw+4*fw*fw+fw)*Position2.vector4_f32[3]+ (fw*fw*fw-fw*fw)*Position3.vector4_f32[3]) }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Catmul2 = {2.0f,2.0f,2.0f,2.0f}; static const XMVECTORF32 Catmul3 = {3.0f,3.0f,3.0f,3.0f}; static const XMVECTORF32 Catmul4 = {4.0f,4.0f,4.0f,4.0f}; static const XMVECTORF32 Catmul5 = {5.0f,5.0f,5.0f,5.0f}; // Cache T^2 and T^3 XMVECTOR T2 = vmulq_f32(T,T); XMVECTOR T3 = vmulq_f32(T,T2); // Perform the Position0 term XMVECTOR vResult = vaddq_f32(T2,T2); vResult = vsubq_f32(vResult,T); vResult = vsubq_f32(vResult,T3); vResult = vmulq_f32(vResult,Position0); // Perform the Position1 term and add XMVECTOR vTemp = vmulq_f32(T3,Catmul3); vTemp = vmlsq_f32(vTemp, T2, Catmul5); vTemp = vaddq_f32(vTemp,Catmul2); vResult = vmlaq_f32(vResult, vTemp, Position1); // Perform the Position2 term and add vTemp = vmulq_f32(T2,Catmul4); vTemp = vmlsq_f32(vTemp, T3, Catmul3); vTemp = vaddq_f32(vTemp,T); vResult = vmlaq_f32(vResult, vTemp, Position2); // Position3 is the last term T3 = vsubq_f32(T3,T2); vResult = vmlaq_f32(vResult, T3, Position3); // Multiply by 0.5f and exit vResult = vmulq_f32(vResult,g_XMOneHalf); return vResult;#elif defined(_XM_SSE_INTRINSICS_) static const XMVECTORF32 Catmul2 = {2.0f,2.0f,2.0f,2.0f}; static const XMVECTORF32 Catmul3 = {3.0f,3.0f,3.0f,3.0f}; static const XMVECTORF32 Catmul4 = {4.0f,4.0f,4.0f,4.0f}; static const XMVECTORF32 Catmul5 = {5.0f,5.0f,5.0f,5.0f}; // Cache T^2 and T^3 XMVECTOR T2 = _mm_mul_ps(T,T); XMVECTOR T3 = _mm_mul_ps(T,T2); // Perform the Position0 term XMVECTOR vResult = _mm_add_ps(T2,T2); vResult = _mm_sub_ps(vResult,T); vResult = _mm_sub_ps(vResult,T3); vResult = _mm_mul_ps(vResult,Position0); // Perform the Position1 term and add XMVECTOR vTemp = _mm_mul_ps(T3,Catmul3); XMVECTOR vTemp2 = _mm_mul_ps(T2,Catmul5); vTemp = _mm_sub_ps(vTemp,vTemp2); vTemp = _mm_add_ps(vTemp,Catmul2); vTemp = _mm_mul_ps(vTemp,Position1); vResult = _mm_add_ps(vResult,vTemp); // Perform the Position2 term and add vTemp = _mm_mul_ps(T2,Catmul4); vTemp2 = _mm_mul_ps(T3,Catmul3); vTemp = _mm_sub_ps(vTemp,vTemp2); vTemp = _mm_add_ps(vTemp,T); vTemp = _mm_mul_ps(vTemp,Position2); vResult = _mm_add_ps(vResult,vTemp); // Position3 is the last term T3 = _mm_sub_ps(T3,T2); T3 = _mm_mul_ps(T3,Position3); vResult = _mm_add_ps(vResult,T3); // Multiply by 0.5f and exit vResult = _mm_mul_ps(vResult,g_XMOneHalf); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorBaryCentric( FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, float f, float g){ // Result = Position0 + f * (Position1 - Position0) + g * (Position2 - Position0)#if defined(_XM_NO_INTRINSICS_) XMVECTOR P10 = XMVectorSubtract(Position1, Position0); XMVECTOR ScaleF = XMVectorReplicate(f); XMVECTOR P20 = XMVectorSubtract(Position2, Position0); XMVECTOR ScaleG = XMVectorReplicate(g); XMVECTOR Result = XMVectorMultiplyAdd(P10, ScaleF, Position0); Result = XMVectorMultiplyAdd(P20, ScaleG, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR R1 = vsubq_f32(Position1,Position0); XMVECTOR SF = vdupq_n_f32(f); XMVECTOR R2 = vsubq_f32(Position2,Position0); XMVECTOR SG = vdupq_n_f32(g); R1 = vmlaq_f32( Position0, R1, SF); return vmlaq_f32( R1, R2, SG );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR R1 = _mm_sub_ps(Position1,Position0); XMVECTOR SF = _mm_set_ps1(f); XMVECTOR R2 = _mm_sub_ps(Position2,Position0); XMVECTOR SG = _mm_set_ps1(g); R1 = _mm_mul_ps(R1,SF); R2 = _mm_mul_ps(R2,SG); R1 = _mm_add_ps(R1,Position0); R1 = _mm_add_ps(R1,R2); return R1;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVectorBaryCentricV( FXMVECTOR Position0, FXMVECTOR Position1, FXMVECTOR Position2, GXMVECTOR F, CXMVECTOR G){ // Result = Position0 + f * (Position1 - Position0) + g * (Position2 - Position0)#if defined(_XM_NO_INTRINSICS_) XMVECTOR P10 = XMVectorSubtract(Position1, Position0); XMVECTOR P20 = XMVectorSubtract(Position2, Position0); XMVECTOR Result = XMVectorMultiplyAdd(P10, F, Position0); Result = XMVectorMultiplyAdd(P20, G, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR R1 = vsubq_f32(Position1,Position0); XMVECTOR R2 = vsubq_f32(Position2,Position0); R1 = vmlaq_f32( Position0, R1, F ); return vmlaq_f32( R1, R2, G);#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR R1 = _mm_sub_ps(Position1,Position0); XMVECTOR R2 = _mm_sub_ps(Position2,Position0); R1 = _mm_mul_ps(R1,F); R2 = _mm_mul_ps(R2,G); R1 = _mm_add_ps(R1,Position0); R1 = _mm_add_ps(R1,R2); return R1;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}/**************************************************************************** * * 2D Vector * ****************************************************************************///------------------------------------------------------------------------------// Comparison operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline bool XMVector2Equal( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vceq_f32( vget_low_f32(V1), vget_low_f32(V2) ); return ( vget_lane_u64( vTemp, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2);// z and w are don't care return (((_mm_movemask_ps(vTemp)&3)==3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector2EqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector2EqualR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] != V2.vector4_f32[0]) && (V1.vector4_f32[1] != V2.vector4_f32[1])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vceq_f32( vget_low_f32(V1), vget_low_f32(V2) ); uint64_t r = vget_lane_u64( vTemp, 0 ); uint32_t CR = 0; if ( r == 0xFFFFFFFFFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2);// z and w are don't care int iTest = _mm_movemask_ps(vTemp)&3; uint32_t CR = 0; if (iTest==3) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector2EqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vceq_u32( vget_low_u32(V1), vget_low_u32(V2) ); return ( vget_lane_u64( vTemp, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp))&3)==3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector2EqualIntR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector2EqualIntR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_u32[0] != V2.vector4_u32[0]) && (V1.vector4_u32[1] != V2.vector4_u32[1])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vceq_u32( vget_low_u32(V1), vget_low_u32(V2) ); uint64_t r = vget_lane_u64( vTemp, 0 ); uint32_t CR = 0; if ( r == 0xFFFFFFFFFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); int iTest = _mm_movemask_ps(_mm_castsi128_ps(vTemp))&3; uint32_t CR = 0; if (iTest==3) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector2NearEqual( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon){#if defined(_XM_NO_INTRINSICS_) float dx = fabsf(V1.vector4_f32[0]-V2.vector4_f32[0]); float dy = fabsf(V1.vector4_f32[1]-V2.vector4_f32[1]); return ((dx <= Epsilon.vector4_f32[0]) && (dy <= Epsilon.vector4_f32[1]));#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vDelta = vsub_f32(vget_low_u32(V1), vget_low_u32(V2)); __n64 vTemp = vacle_f32( vDelta, vget_low_u32(Epsilon) ); uint64_t r = vget_lane_u64( vTemp, 0 ); return ( r == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Get the difference XMVECTOR vDelta = _mm_sub_ps(V1,V2); // Get the absolute value of the difference XMVECTOR vTemp = _mm_setzero_ps(); vTemp = _mm_sub_ps(vTemp,vDelta); vTemp = _mm_max_ps(vTemp,vDelta); vTemp = _mm_cmple_ps(vTemp,Epsilon); // z and w are don't care return (((_mm_movemask_ps(vTemp)&3)==0x3) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector2NotEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] != V2.vector4_f32[0]) || (V1.vector4_f32[1] != V2.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vceq_f32( vget_low_f32(V1), vget_low_f32(V2) ); return ( vget_lane_u64( vTemp, 0 ) != 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2);// z and w are don't care return (((_mm_movemask_ps(vTemp)&3)!=3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAnyFalse(XMVector2EqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline bool XMVector2NotEqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_u32[0] != V2.vector4_u32[0]) || (V1.vector4_u32[1] != V2.vector4_u32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vceq_u32( vget_low_u32(V1), vget_low_u32(V2) ); return ( vget_lane_u64( vTemp, 0 ) != 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp))&3)!=3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAnyFalse(XMVector2EqualIntR(V1, V2));#endif}//------------------------------------------------------------------------------inline bool XMVector2Greater( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vcgt_f32( vget_low_f32(V1), vget_low_f32(V2) ); return ( vget_lane_u64( vTemp, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2);// z and w are don't care return (((_mm_movemask_ps(vTemp)&3)==3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector2GreaterR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector2GreaterR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vcgt_f32( vget_low_f32(V1), vget_low_f32(V2) ); uint64_t r = vget_lane_u64( vTemp, 0 ); uint32_t CR = 0; if ( r == 0xFFFFFFFFFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2); int iTest = _mm_movemask_ps(vTemp)&3; uint32_t CR = 0; if (iTest==3) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector2GreaterOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vcge_f32( vget_low_f32(V1), vget_low_f32(V2) ); return ( vget_lane_u64( vTemp, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&3)==3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector2GreaterOrEqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector2GreaterOrEqualR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vcge_f32( vget_low_f32(V1), vget_low_f32(V2) ); uint64_t r = vget_lane_u64( vTemp, 0 ); uint32_t CR = 0; if ( r == 0xFFFFFFFFFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); int iTest = _mm_movemask_ps(vTemp)&3; uint32_t CR = 0; if (iTest == 3) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector2Less( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vclt_f32( vget_low_f32(V1), vget_low_f32(V2) ); return ( vget_lane_u64( vTemp, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmplt_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&3)==3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector2GreaterR(V2, V1));#endif}//------------------------------------------------------------------------------inline bool XMVector2LessOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 vTemp = vcle_f32( vget_low_f32(V1), vget_low_f32(V2) ); return ( vget_lane_u64( vTemp, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmple_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&3)==3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector2GreaterOrEqualR(V2, V1));#endif}//------------------------------------------------------------------------------inline bool XMVector2InBounds( FXMVECTOR V, FXMVECTOR Bounds){#if defined(_XM_NO_INTRINSICS_) return (((V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) && (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); __n64 B = vget_low_f32( Bounds ); // Test if less than or equal __n64 vTemp1 = vcle_f32(VL,B); // Negate the bounds __n64 vTemp2 = vneg_f32(B); // Test if greater or equal (Reversed) vTemp2 = vcle_f32(vTemp2,VL); // Blend answers vTemp1 = vand_u32(vTemp1,vTemp2); // x and y in bounds? return ( vget_lane_u64( vTemp1, 0 ) == 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = _mm_cmple_ps(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = _mm_mul_ps(Bounds,g_XMNegativeOne); // Test if greater or equal (Reversed) vTemp2 = _mm_cmple_ps(vTemp2,V); // Blend answers vTemp1 = _mm_and_ps(vTemp1,vTemp2); // x and y in bounds? (z and w are don't care) return (((_mm_movemask_ps(vTemp1)&0x3)==0x3) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllInBounds(XMVector2InBoundsR(V, Bounds));#endif}//------------------------------------------------------------------------------inline bool XMVector2IsNaN( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return (XMISNAN(V.vector4_f32[0]) || XMISNAN(V.vector4_f32[1]));#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); // Test against itself. NaN is always not equal __n64 vTempNan = vceq_f32( VL, VL ); // If x or y are NaN, the mask is zero return ( vget_lane_u64( vTempNan, 0 ) != 0xFFFFFFFFFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Test against itself. NaN is always not equal XMVECTOR vTempNan = _mm_cmpneq_ps(V,V); // If x or y are NaN, the mask is non-zero return ((_mm_movemask_ps(vTempNan)&3) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector2IsInfinite( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return (XMISINF(V.vector4_f32[0]) || XMISINF(V.vector4_f32[1]));#elif defined(_XM_ARM_NEON_INTRINSICS_) // Mask off the sign bit __n64 vTemp = vand_u32( vget_low_f32( V ) , vget_low_f32( g_XMAbsMask ) ); // Compare to infinity vTemp = vceq_f32(vTemp, vget_low_f32( g_XMInfinity) ); // If any are infinity, the signs are true. return vget_lane_u64( vTemp, 0 ) != 0;#elif defined(_XM_SSE_INTRINSICS_) // Mask off the sign bit __m128 vTemp = _mm_and_ps(V,g_XMAbsMask); // Compare to infinity vTemp = _mm_cmpeq_ps(vTemp,g_XMInfinity); // If x or z are infinity, the signs are true. return ((_mm_movemask_ps(vTemp)&3) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Computation operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline XMVECTOR XMVector2Dot( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = Result.vector4_f32[1] = Result.vector4_f32[2] = Result.vector4_f32[3] = V1.vector4_f32[0] * V2.vector4_f32[0] + V1.vector4_f32[1] * V2.vector4_f32[1]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Perform the dot product on x and y __n64 vTemp = vmul_f32( vget_low_f32(V1), vget_low_f32(V2) ); vTemp = vpadd_f32( vTemp, vTemp ); return vcombine_f32( vTemp, vTemp );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y XMVECTOR vLengthSq = _mm_mul_ps(V1,V2); // vTemp has y splatted XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); // x+y vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Cross( FXMVECTOR V1, FXMVECTOR V2){ // [ V1.x*V2.y - V1.y*V2.x, V1.x*V2.y - V1.y*V2.x ]#if defined(_XM_NO_INTRINSICS_) float fCross = (V1.vector4_f32[0] * V2.vector4_f32[1]) - (V1.vector4_f32[1] * V2.vector4_f32[0]); XMVECTOR vResult = { fCross, fCross, fCross, fCross }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Negate = { 1.f, -1.f, 0, 0 }; __n64 vTemp = vmul_f32( vget_low_f32( V1 ), vrev64_f32( vget_low_f32( V2 ) ) ); vTemp = vmul_f32( vTemp, vget_low_f32( Negate ) ); vTemp = vpadd_f32( vTemp, vTemp ); return vcombine_f32( vTemp, vTemp );#elif defined(_XM_SSE_INTRINSICS_) // Swap x and y XMVECTOR vResult = XM_PERMUTE_PS(V2,_MM_SHUFFLE(0,1,0,1)); // Perform the muls vResult = _mm_mul_ps(vResult,V1); // Splat y XMVECTOR vTemp = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(1,1,1,1)); // Sub the values vResult = _mm_sub_ss(vResult,vTemp); // Splat the cross product vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(0,0,0,0)); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2LengthSq( FXMVECTOR V){ return XMVector2Dot(V, V);}//------------------------------------------------------------------------------inline XMVECTOR XMVector2ReciprocalLengthEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector2LengthSq(V); Result = XMVectorReciprocalSqrtEst(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32(V); // Dot2 __n64 vTemp = vmul_f32( VL, VL ); vTemp = vpadd_f32( vTemp, vTemp ); // Reciprocal sqrt (estimate) vTemp = vrsqrte_f32( vTemp ); return vcombine_f32( vTemp, vTemp );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has y splatted XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); // x+y vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = _mm_rsqrt_ss(vLengthSq); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2ReciprocalLength( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector2LengthSq(V); Result = XMVectorReciprocalSqrt(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32(V); // Dot2 __n64 vTemp = vmul_f32( VL, VL ); vTemp = vpadd_f32( vTemp, vTemp ); // Reciprocal sqrt __n64 S0 = vrsqrte_f32(vTemp); __n64 P0 = vmul_f32( vTemp, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( vTemp, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 Result = vmul_f32( S1, R1 ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has y splatted XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); // x+y vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = _mm_sqrt_ss(vLengthSq); vLengthSq = _mm_div_ss(g_XMOne,vLengthSq); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2LengthEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector2LengthSq(V); Result = XMVectorSqrtEst(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32(V); // Dot2 __n64 vTemp = vmul_f32( VL, VL ); vTemp = vpadd_f32( vTemp, vTemp ); const __n64 zero = vdup_n_u32(0); __n64 VEqualsZero = vceq_f32( vTemp, zero ); // Sqrt (estimate) __n64 Result = vrsqrte_f32( vTemp ); Result = vmul_f32( vTemp, Result ); Result = vbsl_f32( VEqualsZero, zero, Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has y splatted XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); // x+y vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = _mm_sqrt_ss(vLengthSq); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Length( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector2LengthSq(V); Result = XMVectorSqrt(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32(V); // Dot2 __n64 vTemp = vmul_f32( VL, VL ); vTemp = vpadd_f32( vTemp, vTemp ); const __n64 zero = vdup_n_u32(0); __n64 VEqualsZero = vceq_f32( vTemp, zero ); // Sqrt __n64 S0 = vrsqrte_f32( vTemp ); __n64 P0 = vmul_f32( vTemp, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( vTemp, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 Result = vmul_f32( S1, R1 ); Result = vmul_f32( vTemp, Result ); Result = vbsl_f32( VEqualsZero, zero, Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has y splatted XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); // x+y vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); vLengthSq = _mm_sqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// XMVector2NormalizeEst uses a reciprocal estimate and// returns QNaN on zero and infinite vectors.inline XMVECTOR XMVector2NormalizeEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector2ReciprocalLength(V); Result = XMVectorMultiply(V, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32(V); // Dot2 __n64 vTemp = vmul_f32( VL, VL ); vTemp = vpadd_f32( vTemp, vTemp ); // Reciprocal sqrt (estimate) vTemp = vrsqrte_f32( vTemp ); // Normalize __n64 Result = vmul_f32( VL, vTemp ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has y splatted XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); // x+y vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = _mm_rsqrt_ss(vLengthSq); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); vLengthSq = _mm_mul_ps(vLengthSq,V); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Normalize( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = XMVector2Length( V ); float fLength = vResult.vector4_f32[0]; // Prevent divide by zero if (fLength > 0) { fLength = 1.0f/fLength; } vResult.vector4_f32[0] = V.vector4_f32[0]*fLength; vResult.vector4_f32[1] = V.vector4_f32[1]*fLength; vResult.vector4_f32[2] = V.vector4_f32[2]*fLength; vResult.vector4_f32[3] = V.vector4_f32[3]*fLength; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32(V); // Dot2 __n64 vTemp = vmul_f32( VL, VL ); vTemp = vpadd_f32( vTemp, vTemp ); __n64 VEqualsZero = vceq_f32( vTemp, vdup_n_u32(0) ); __n64 VEqualsInf = vceq_f32( vTemp, vget_low_f32(g_XMInfinity) ); // Reciprocal sqrt (2 iterations of Newton-Raphson) __n64 S0 = vrsqrte_f32( vTemp ); __n64 P0 = vmul_f32( vTemp, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( vTemp, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); vTemp = vmul_f32( S1, R1 ); // Normalize __n64 Result = vmul_f32( VL, vTemp ); Result = vbsl_f32( VEqualsZero, vdup_n_f32(0), Result ); Result = vbsl_f32( VEqualsInf, vget_low_f32(g_XMQNaN), Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x and y only XMVECTOR vLengthSq = _mm_mul_ps(V,V); XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,1,1,1)); vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); // Prepare for the division XMVECTOR vResult = _mm_sqrt_ps(vLengthSq); // Create zero with a single instruction XMVECTOR vZeroMask = _mm_setzero_ps(); // Test for a divide by zero (Must be FP to detect -0.0) vZeroMask = _mm_cmpneq_ps(vZeroMask,vResult); // Failsafe on zero (Or epsilon) length planes // If the length is infinity, set the elements to zero vLengthSq = _mm_cmpneq_ps(vLengthSq,g_XMInfinity); // Reciprocal mul to perform the normalization vResult = _mm_div_ps(V,vResult); // Any that are infinity, set to zero vResult = _mm_and_ps(vResult,vZeroMask); // Select qnan or result based on infinite length XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq,g_XMQNaN); XMVECTOR vTemp2 = _mm_and_ps(vResult,vLengthSq); vResult = _mm_or_ps(vTemp1,vTemp2); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2ClampLength( FXMVECTOR V, float LengthMin, float LengthMax){ XMVECTOR ClampMax = XMVectorReplicate(LengthMax); XMVECTOR ClampMin = XMVectorReplicate(LengthMin); return XMVector2ClampLengthV(V, ClampMin, ClampMax);}//------------------------------------------------------------------------------inline XMVECTOR XMVector2ClampLengthV( FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax){ assert((XMVectorGetY(LengthMin) == XMVectorGetX(LengthMin))); assert((XMVectorGetY(LengthMax) == XMVectorGetX(LengthMax))); assert(XMVector2GreaterOrEqual(LengthMin, g_XMZero)); assert(XMVector2GreaterOrEqual(LengthMax, g_XMZero)); assert(XMVector2GreaterOrEqual(LengthMax, LengthMin)); XMVECTOR LengthSq = XMVector2LengthSq(V); const XMVECTOR Zero = XMVectorZero(); XMVECTOR RcpLength = XMVectorReciprocalSqrt(LengthSq); XMVECTOR InfiniteLength = XMVectorEqualInt(LengthSq, g_XMInfinity.v); XMVECTOR ZeroLength = XMVectorEqual(LengthSq, Zero); XMVECTOR Length = XMVectorMultiply(LengthSq, RcpLength); XMVECTOR Normal = XMVectorMultiply(V, RcpLength); XMVECTOR Select = XMVectorEqualInt(InfiniteLength, ZeroLength); Length = XMVectorSelect(LengthSq, Length, Select); Normal = XMVectorSelect(LengthSq, Normal, Select); XMVECTOR ControlMax = XMVectorGreater(Length, LengthMax); XMVECTOR ControlMin = XMVectorLess(Length, LengthMin); XMVECTOR ClampLength = XMVectorSelect(Length, LengthMax, ControlMax); ClampLength = XMVectorSelect(ClampLength, LengthMin, ControlMin); XMVECTOR Result = XMVectorMultiply(Normal, ClampLength); // Preserve the original vector (with no precision loss) if the length falls within the given range XMVECTOR Control = XMVectorEqualInt(ControlMax, ControlMin); Result = XMVectorSelect(Result, V, Control); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Reflect( FXMVECTOR Incident, FXMVECTOR Normal){ // Result = Incident - (2 * dot(Incident, Normal)) * Normal XMVECTOR Result; Result = XMVector2Dot(Incident, Normal); Result = XMVectorAdd(Result, Result); Result = XMVectorNegativeMultiplySubtract(Result, Normal, Incident); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Refract( FXMVECTOR Incident, FXMVECTOR Normal, float RefractionIndex){ XMVECTOR Index = XMVectorReplicate(RefractionIndex); return XMVector2RefractV(Incident, Normal, Index);}//------------------------------------------------------------------------------// Return the refraction of a 2D vectorinline XMVECTOR XMVector2RefractV( FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex){ // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) + // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))#if defined(_XM_NO_INTRINSICS_) float IDotN = (Incident.vector4_f32[0]*Normal.vector4_f32[0])+(Incident.vector4_f32[1]*Normal.vector4_f32[1]); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) float RY = 1.0f-(IDotN*IDotN); float RX = 1.0f-(RY*RefractionIndex.vector4_f32[0]*RefractionIndex.vector4_f32[0]); RY = 1.0f-(RY*RefractionIndex.vector4_f32[1]*RefractionIndex.vector4_f32[1]); if (RX>=0.0f) { RX = (RefractionIndex.vector4_f32[0]*Incident.vector4_f32[0])-(Normal.vector4_f32[0]*((RefractionIndex.vector4_f32[0]*IDotN)+sqrtf(RX))); } else { RX = 0.0f; } if (RY>=0.0f) { RY = (RefractionIndex.vector4_f32[1]*Incident.vector4_f32[1])-(Normal.vector4_f32[1]*((RefractionIndex.vector4_f32[1]*IDotN)+sqrtf(RY))); } else { RY = 0.0f; } XMVECTOR vResult; vResult.vector4_f32[0] = RX; vResult.vector4_f32[1] = RY; vResult.vector4_f32[2] = 0.0f; vResult.vector4_f32[3] = 0.0f; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 IL = vget_low_f32( Incident ); __n64 NL = vget_low_f32( Normal ); __n64 RIL = vget_low_f32( RefractionIndex ); // Get the 2D Dot product of Incident-Normal __n64 vTemp = vmul_f32(IL, NL); __n64 IDotN = vpadd_f32( vTemp, vTemp ); // vTemp = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) vTemp = vmls_f32( vget_low_f32( g_XMOne ), IDotN, IDotN); vTemp = vmul_f32(vTemp,RIL); vTemp = vmls_f32(vget_low_f32( g_XMOne ), vTemp, RIL ); // If any terms are <=0, sqrt() will fail, punt to zero __n64 vMask = vcgt_f32(vTemp, vget_low_f32(g_XMZero) ); // Sqrt(vTemp) __n64 S0 = vrsqrte_f32(vTemp); __n64 P0 = vmul_f32( vTemp, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( vTemp, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 S2 = vmul_f32( S1, R1 ); vTemp = vmul_f32( vTemp, S2 ); // R = RefractionIndex * IDotN + sqrt(R) vTemp = vmla_f32( vTemp, RIL, IDotN ); // Result = RefractionIndex * Incident - Normal * R __n64 vResult = vmul_f32(RIL,IL); vResult = vmls_f32( vResult, vTemp, NL ); vResult = vand_u32(vResult,vMask); return vcombine_f32(vResult, vResult);#elif defined(_XM_SSE_INTRINSICS_) // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) + // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal)))) // Get the 2D Dot product of Incident-Normal XMVECTOR IDotN = XMVector2Dot(Incident, Normal); // vTemp = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) XMVECTOR vTemp = _mm_mul_ps(IDotN,IDotN); vTemp = _mm_sub_ps(g_XMOne,vTemp); vTemp = _mm_mul_ps(vTemp,RefractionIndex); vTemp = _mm_mul_ps(vTemp,RefractionIndex); vTemp = _mm_sub_ps(g_XMOne,vTemp); // If any terms are <=0, sqrt() will fail, punt to zero XMVECTOR vMask = _mm_cmpgt_ps(vTemp,g_XMZero); // R = RefractionIndex * IDotN + sqrt(R) vTemp = _mm_sqrt_ps(vTemp); XMVECTOR vResult = _mm_mul_ps(RefractionIndex,IDotN); vTemp = _mm_add_ps(vTemp,vResult); // Result = RefractionIndex * Incident - Normal * R vResult = _mm_mul_ps(RefractionIndex,Incident); vTemp = _mm_mul_ps(vTemp,Normal); vResult = _mm_sub_ps(vResult,vTemp); vResult = _mm_and_ps(vResult,vMask); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Orthogonal( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = -V.vector4_f32[1]; Result.vector4_f32[1] = V.vector4_f32[0]; Result.vector4_f32[2] = 0.f; Result.vector4_f32[3] = 0.f; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Negate = { -1.f, 1.f, 0, 0 }; const __n64 zero = vdup_n_f32(0); __n64 VL = vget_low_f32( V ); __n64 Result = vmul_f32( vrev64_f32( VL ), vget_low_f32( Negate ) ); return vcombine_f32( Result, zero );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,2,0,1)); vResult = _mm_mul_ps(vResult,g_XMNegateX); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2AngleBetweenNormalsEst( FXMVECTOR N1, FXMVECTOR N2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Result = XMVector2Dot(N1, N2); Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v); Result = XMVectorACosEst(Result); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2AngleBetweenNormals( FXMVECTOR N1, FXMVECTOR N2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Result = XMVector2Dot(N1, N2); Result = XMVectorClamp(Result, g_XMNegativeOne, g_XMOne); Result = XMVectorACos(Result); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2AngleBetweenVectors( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR L1 = XMVector2ReciprocalLength(V1); XMVECTOR L2 = XMVector2ReciprocalLength(V2); XMVECTOR Dot = XMVector2Dot(V1, V2); L1 = XMVectorMultiply(L1, L2); XMVECTOR CosAngle = XMVectorMultiply(Dot, L1); CosAngle = XMVectorClamp(CosAngle, g_XMNegativeOne.v, g_XMOne.v); return XMVectorACos(CosAngle);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2LinePointDistance( FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point){ // Given a vector PointVector from LinePoint1 to Point and a vector // LineVector from LinePoint1 to LinePoint2, the scaled distance // PointProjectionScale from LinePoint1 to the perpendicular projection // of PointVector onto the line is defined as: // // PointProjectionScale = dot(PointVector, LineVector) / LengthSq(LineVector)#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR PointVector = XMVectorSubtract(Point, LinePoint1); XMVECTOR LineVector = XMVectorSubtract(LinePoint2, LinePoint1); XMVECTOR LengthSq = XMVector2LengthSq(LineVector); XMVECTOR PointProjectionScale = XMVector2Dot(PointVector, LineVector); PointProjectionScale = XMVectorDivide(PointProjectionScale, LengthSq); XMVECTOR DistanceVector = XMVectorMultiply(LineVector, PointProjectionScale); DistanceVector = XMVectorSubtract(PointVector, DistanceVector); return XMVector2Length(DistanceVector);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2IntersectLine( FXMVECTOR Line1Point1, FXMVECTOR Line1Point2, FXMVECTOR Line2Point1, GXMVECTOR Line2Point2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR V1 = XMVectorSubtract(Line1Point2, Line1Point1); XMVECTOR V2 = XMVectorSubtract(Line2Point2, Line2Point1); XMVECTOR V3 = XMVectorSubtract(Line1Point1, Line2Point1); XMVECTOR C1 = XMVector2Cross(V1, V2); XMVECTOR C2 = XMVector2Cross(V2, V3); XMVECTOR Result; const XMVECTOR Zero = XMVectorZero(); if (XMVector2NearEqual(C1, Zero, g_XMEpsilon.v)) { if (XMVector2NearEqual(C2, Zero, g_XMEpsilon.v)) { // Coincident Result = g_XMInfinity.v; } else { // Parallel Result = g_XMQNaN.v; } } else { // Intersection point = Line1Point1 + V1 * (C2 / C1) XMVECTOR Scale = XMVectorReciprocal(C1); Scale = XMVectorMultiply(C2, Scale); Result = XMVectorMultiplyAdd(V1, Scale, Line1Point1); } return Result;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR V1 = _mm_sub_ps(Line1Point2, Line1Point1); XMVECTOR V2 = _mm_sub_ps(Line2Point2, Line2Point1); XMVECTOR V3 = _mm_sub_ps(Line1Point1, Line2Point1); // Generate the cross products XMVECTOR C1 = XMVector2Cross(V1, V2); XMVECTOR C2 = XMVector2Cross(V2, V3); // If C1 is not close to epsilon, use the calculated value XMVECTOR vResultMask = _mm_setzero_ps(); vResultMask = _mm_sub_ps(vResultMask,C1); vResultMask = _mm_max_ps(vResultMask,C1); // 0xFFFFFFFF if the calculated value is to be used vResultMask = _mm_cmpgt_ps(vResultMask,g_XMEpsilon); // If C1 is close to epsilon, which fail type is it? INFINITY or NAN? XMVECTOR vFailMask = _mm_setzero_ps(); vFailMask = _mm_sub_ps(vFailMask,C2); vFailMask = _mm_max_ps(vFailMask,C2); vFailMask = _mm_cmple_ps(vFailMask,g_XMEpsilon); XMVECTOR vFail = _mm_and_ps(vFailMask,g_XMInfinity); vFailMask = _mm_andnot_ps(vFailMask,g_XMQNaN); // vFail is NAN or INF vFail = _mm_or_ps(vFail,vFailMask); // Intersection point = Line1Point1 + V1 * (C2 / C1) XMVECTOR vResult = _mm_div_ps(C2,C1); vResult = _mm_mul_ps(vResult,V1); vResult = _mm_add_ps(vResult,Line1Point1); // Use result, or failure value vResult = _mm_and_ps(vResult,vResultMask); vResultMask = _mm_andnot_ps(vResultMask,vFail); vResult = _mm_or_ps(vResult,vResultMask); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2Transform( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Y, M.r[1], M.r[3]); Result = XMVectorMultiplyAdd(X, M.r[0], Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); __n128 Y = vdupq_lane_f32( VL, 1 ); __n128 Result = vmlaq_f32( M.r[3], Y, M.r[1] ); __n128 X = vdupq_lane_f32( VL, 0 ); return vmlaq_f32( Result, X, M.r[0] );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,0,0,0)); vResult = _mm_mul_ps(vResult,M.r[0]); XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); vTemp = _mm_mul_ps(vTemp,M.r[1]); vResult = _mm_add_ps(vResult,vTemp); vResult = _mm_add_ps(vResult,M.r[3]); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT4* XMVector2TransformStream( XMFLOAT4* pOutputStream, size_t OutputStride, const XMFLOAT2* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; const XMVECTOR row3 = M.r[3]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat2((const XMFLOAT2*)pInputVector); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Y, row1, row3); Result = XMVectorMultiplyAdd(X, row0, Result); XMStoreFloat4((XMFLOAT4*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2TransformCoord( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Y, M.r[1], M.r[3]); Result = XMVectorMultiplyAdd(X, M.r[0], Result); XMVECTOR W = XMVectorSplatW(Result); return XMVectorDivide( Result, W );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT2* XMVector2TransformCoordStream( XMFLOAT2* pOutputStream, size_t OutputStride, const XMFLOAT2* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; const XMVECTOR row3 = M.r[3]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat2((const XMFLOAT2*)pInputVector); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Y, row1, row3); Result = XMVectorMultiplyAdd(X, row0, Result); XMVECTOR W = XMVectorSplatW(Result); Result = XMVectorDivide(Result, W); XMStoreFloat2((XMFLOAT2*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector2TransformNormal( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiply(Y, M.r[1]); Result = XMVectorMultiplyAdd(X, M.r[0], Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); __n128 Y = vdupq_lane_f32( VL, 1 ); __n128 Result = vmulq_f32( Y, M.r[1] ); __n128 X = vdupq_lane_f32( VL, 0 ); return vmlaq_f32( Result, X, M.r[0] );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,0,0,0)); vResult = _mm_mul_ps(vResult,M.r[0]); XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); vTemp = _mm_mul_ps(vTemp,M.r[1]); vResult = _mm_add_ps(vResult,vTemp); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT2* XMVector2TransformNormalStream( XMFLOAT2* pOutputStream, size_t OutputStride, const XMFLOAT2* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat2((const XMFLOAT2*)pInputVector); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiply(Y, row1); Result = XMVectorMultiplyAdd(X, row0, Result); XMStoreFloat2((XMFLOAT2*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}/**************************************************************************** * * 3D Vector * ****************************************************************************///------------------------------------------------------------------------------// Comparison operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline bool XMVector3Equal( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1]) && (V1.vector4_f32[2] == V2.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&7)==7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector3EqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector3EqualR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1]) && (V1.vector4_f32[2] == V2.vector4_f32[2])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] != V2.vector4_f32[0]) && (V1.vector4_f32[1] != V2.vector4_f32[1]) && (V1.vector4_f32[2] != V2.vector4_f32[2])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU; uint32_t CR = 0; if ( r == 0xFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2); int iTest = _mm_movemask_ps(vTemp)&7; uint32_t CR = 0; if (iTest==7) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector3EqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1]) && (V1.vector4_u32[2] == V2.vector4_u32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp))&7)==7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector3EqualIntR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector3EqualIntR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1]) && (V1.vector4_u32[2] == V2.vector4_u32[2])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_u32[0] != V2.vector4_u32[0]) && (V1.vector4_u32[1] != V2.vector4_u32[1]) && (V1.vector4_u32[2] != V2.vector4_u32[2])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU; uint32_t CR = 0; if ( r == 0xFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); int iTemp = _mm_movemask_ps(_mm_castsi128_ps(vTemp))&7; uint32_t CR = 0; if (iTemp==7) { CR = XM_CRMASK_CR6TRUE; } else if (!iTemp) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector3NearEqual( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon){#if defined(_XM_NO_INTRINSICS_) float dx, dy, dz; dx = fabsf(V1.vector4_f32[0]-V2.vector4_f32[0]); dy = fabsf(V1.vector4_f32[1]-V2.vector4_f32[1]); dz = fabsf(V1.vector4_f32[2]-V2.vector4_f32[2]); return (((dx <= Epsilon.vector4_f32[0]) && (dy <= Epsilon.vector4_f32[1]) && (dz <= Epsilon.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vDelta = vsubq_f32( V1, V2 ); __n128 vResult = vacleq_f32( vDelta, Epsilon ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Get the difference XMVECTOR vDelta = _mm_sub_ps(V1,V2); // Get the absolute value of the difference XMVECTOR vTemp = _mm_setzero_ps(); vTemp = _mm_sub_ps(vTemp,vDelta); vTemp = _mm_max_ps(vTemp,vDelta); vTemp = _mm_cmple_ps(vTemp,Epsilon); // w is don't care return (((_mm_movemask_ps(vTemp)&7)==0x7) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector3NotEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] != V2.vector4_f32[0]) || (V1.vector4_f32[1] != V2.vector4_f32[1]) || (V1.vector4_f32[2] != V2.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) != 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&7)!=7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAnyFalse(XMVector3EqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline bool XMVector3NotEqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_u32[0] != V2.vector4_u32[0]) || (V1.vector4_u32[1] != V2.vector4_u32[1]) || (V1.vector4_u32[2] != V2.vector4_u32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) != 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); return (((_mm_movemask_ps(_mm_castsi128_ps(vTemp))&7)!=7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAnyFalse(XMVector3EqualIntR(V1, V2));#endif}//------------------------------------------------------------------------------inline bool XMVector3Greater( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1]) && (V1.vector4_f32[2] > V2.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgtq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&7)==7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector3GreaterR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector3GreaterR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1]) && (V1.vector4_f32[2] > V2.vector4_f32[2])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1]) && (V1.vector4_f32[2] <= V2.vector4_f32[2])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgtq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU; uint32_t CR = 0; if ( r == 0xFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2); uint32_t CR = 0; int iTest = _mm_movemask_ps(vTemp)&7; if (iTest==7) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector3GreaterOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1]) && (V1.vector4_f32[2] >= V2.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgeq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&7)==7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector3GreaterOrEqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector3GreaterOrEqualR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1]) && (V1.vector4_f32[2] >= V2.vector4_f32[2])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1]) && (V1.vector4_f32[2] < V2.vector4_f32[2])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgeq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU; uint32_t CR = 0; if ( r == 0xFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); uint32_t CR = 0; int iTest = _mm_movemask_ps(vTemp)&7; if (iTest==7) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector3Less( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1]) && (V1.vector4_f32[2] < V2.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcltq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmplt_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&7)==7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector3GreaterR(V2, V1));#endif}//------------------------------------------------------------------------------inline bool XMVector3LessOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1]) && (V1.vector4_f32[2] <= V2.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcleq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmple_ps(V1,V2); return (((_mm_movemask_ps(vTemp)&7)==7) != 0);#else // _XM_VMX128_INTRINSICS_ return XMComparisonAllTrue(XMVector3GreaterOrEqualR(V2, V1));#endif}//------------------------------------------------------------------------------inline bool XMVector3InBounds( FXMVECTOR V, FXMVECTOR Bounds){#if defined(_XM_NO_INTRINSICS_) return (((V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) && (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) && (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test if less than or equal __n128 vTemp1 = vcleq_f32(V,Bounds); // Negate the bounds __n128 vTemp2 = vnegq_f32(Bounds); // Test if greater or equal (Reversed) vTemp2 = vcleq_f32(vTemp2,V); // Blend answers vTemp1 = vandq_u32(vTemp1,vTemp2); // in bounds? int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTemp1), vget_high_u8(vTemp1)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) == 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = _mm_cmple_ps(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = _mm_mul_ps(Bounds,g_XMNegativeOne); // Test if greater or equal (Reversed) vTemp2 = _mm_cmple_ps(vTemp2,V); // Blend answers vTemp1 = _mm_and_ps(vTemp1,vTemp2); // x,y and z in bounds? (w is don't care) return (((_mm_movemask_ps(vTemp1)&0x7)==0x7) != 0);#else return XMComparisonAllInBounds(XMVector3InBoundsR(V, Bounds));#endif}//------------------------------------------------------------------------------inline bool XMVector3IsNaN( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return (XMISNAN(V.vector4_f32[0]) || XMISNAN(V.vector4_f32[1]) || XMISNAN(V.vector4_f32[2]));#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test against itself. NaN is always not equal __n128 vTempNan = vceqq_f32( V, V ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTempNan), vget_high_u8(vTempNan)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); // If x or y or z are NaN, the mask is zero return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) != 0xFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Test against itself. NaN is always not equal XMVECTOR vTempNan = _mm_cmpneq_ps(V,V); // If x or y or z are NaN, the mask is non-zero return ((_mm_movemask_ps(vTempNan)&7) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector3IsInfinite( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return (XMISINF(V.vector4_f32[0]) || XMISINF(V.vector4_f32[1]) || XMISINF(V.vector4_f32[2]));#elif defined(_XM_ARM_NEON_INTRINSICS_) // Mask off the sign bit __n128 vTempInf = vandq_u32( V, g_XMAbsMask ); // Compare to infinity vTempInf = vceqq_f32(vTempInf, g_XMInfinity ); // If any are infinity, the signs are true. int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTempInf), vget_high_u8(vTempInf)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( (vget_lane_u32(vTemp.val[1], 1) & 0xFFFFFFU) != 0 );#elif defined(_XM_SSE_INTRINSICS_) // Mask off the sign bit __m128 vTemp = _mm_and_ps(V,g_XMAbsMask); // Compare to infinity vTemp = _mm_cmpeq_ps(vTemp,g_XMInfinity); // If x,y or z are infinity, the signs are true. return ((_mm_movemask_ps(vTemp)&7) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Computation operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline XMVECTOR XMVector3Dot( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) float fValue = V1.vector4_f32[0] * V2.vector4_f32[0] + V1.vector4_f32[1] * V2.vector4_f32[1] + V1.vector4_f32[2] * V2.vector4_f32[2]; XMVECTOR vResult = { fValue, fValue, fValue, fValue }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vTemp = vmulq_f32( V1, V2 ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); return vcombine_f32( v1, v1 );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product XMVECTOR vDot = _mm_mul_ps(V1,V2); // x=Dot.vector4_f32[1], y=Dot.vector4_f32[2] XMVECTOR vTemp = XM_PERMUTE_PS(vDot,_MM_SHUFFLE(2,1,2,1)); // Result.vector4_f32[0] = x+y vDot = _mm_add_ss(vDot,vTemp); // x=Dot.vector4_f32[2] vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); // Result.vector4_f32[0] = (x+y)+z vDot = _mm_add_ss(vDot,vTemp); // Splat x return XM_PERMUTE_PS(vDot,_MM_SHUFFLE(0,0,0,0));#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Cross( FXMVECTOR V1, FXMVECTOR V2){ // [ V1.y*V2.z - V1.z*V2.y, V1.z*V2.x - V1.x*V2.z, V1.x*V2.y - V1.y*V2.x ]#if defined(_XM_NO_INTRINSICS_) XMVECTOR vResult = { (V1.vector4_f32[1] * V2.vector4_f32[2]) - (V1.vector4_f32[2] * V2.vector4_f32[1]), (V1.vector4_f32[2] * V2.vector4_f32[0]) - (V1.vector4_f32[0] * V2.vector4_f32[2]), (V1.vector4_f32[0] * V2.vector4_f32[1]) - (V1.vector4_f32[1] * V2.vector4_f32[0]), 0.0f }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 v1xy = vget_low_f32(V1); __n64 v2xy = vget_low_f32(V2); __n64 v1yx = vrev64_f32( v1xy ); __n64 v2yx = vrev64_f32( v2xy ); __n64 v1zz = vdup_lane_f32( vget_high_f32(V1), 0 ); __n64 v2zz = vdup_lane_f32( vget_high_f32(V2), 0 ); __n128 vResult = vmulq_f32( vcombine_f32(v1yx,v1xy), vcombine_f32(v2zz,v2yx) ); vResult = vmlsq_f32( vResult, vcombine_f32(v1zz,v1yx), vcombine_f32(v2yx,v2xy) ); return veorq_u32( vResult, g_XMFlipY );#elif defined(_XM_SSE_INTRINSICS_) // y1,z1,x1,w1 XMVECTOR vTemp1 = XM_PERMUTE_PS(V1,_MM_SHUFFLE(3,0,2,1)); // z2,x2,y2,w2 XMVECTOR vTemp2 = XM_PERMUTE_PS(V2,_MM_SHUFFLE(3,1,0,2)); // Perform the left operation XMVECTOR vResult = _mm_mul_ps(vTemp1,vTemp2); // z1,x1,y1,w1 vTemp1 = XM_PERMUTE_PS(vTemp1,_MM_SHUFFLE(3,0,2,1)); // y2,z2,x2,w2 vTemp2 = XM_PERMUTE_PS(vTemp2,_MM_SHUFFLE(3,1,0,2)); // Perform the right operation vTemp1 = _mm_mul_ps(vTemp1,vTemp2); // Subract the right from left, and return answer vResult = _mm_sub_ps(vResult,vTemp1); // Set w to zero return _mm_and_ps(vResult,g_XMMask3);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3LengthSq( FXMVECTOR V){ return XMVector3Dot(V, V);}//------------------------------------------------------------------------------inline XMVECTOR XMVector3ReciprocalLengthEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector3LengthSq(V); Result = XMVectorReciprocalSqrtEst(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot3 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); // Reciprocal sqrt (estimate) v2 = vrsqrte_f32( v1 ); return vcombine_f32(v2, v2);#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y and z XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and y XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,2,1,2)); // x+z, y vLengthSq = _mm_add_ss(vLengthSq,vTemp); // y,y,y,y vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); // x+z+y,??,??,?? vLengthSq = _mm_add_ss(vLengthSq,vTemp); // Splat the length squared vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); // Get the reciprocal vLengthSq = _mm_rsqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3ReciprocalLength( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector3LengthSq(V); Result = XMVectorReciprocalSqrt(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot3 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); // Reciprocal sqrt __n64 S0 = vrsqrte_f32(v1); __n64 P0 = vmul_f32( v1, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( v1, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 Result = vmul_f32( S1, R1 ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product XMVECTOR vDot = _mm_mul_ps(V,V); // x=Dot.y, y=Dot.z XMVECTOR vTemp = XM_PERMUTE_PS(vDot,_MM_SHUFFLE(2,1,2,1)); // Result.x = x+y vDot = _mm_add_ss(vDot,vTemp); // x=Dot.z vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); // Result.x = (x+y)+z vDot = _mm_add_ss(vDot,vTemp); // Splat x vDot = XM_PERMUTE_PS(vDot,_MM_SHUFFLE(0,0,0,0)); // Get the reciprocal vDot = _mm_sqrt_ps(vDot); // Get the reciprocal vDot = _mm_div_ps(g_XMOne,vDot); return vDot;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3LengthEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector3LengthSq(V); Result = XMVectorSqrtEst(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot3 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); const __n64 zero = vdup_n_u32(0); __n64 VEqualsZero = vceq_f32( v1, zero ); // Sqrt (estimate) __n64 Result = vrsqrte_f32( v1 ); Result = vmul_f32( v1, Result ); Result = vbsl_f32( VEqualsZero, zero, Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y and z XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and y XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,2,1,2)); // x+z, y vLengthSq = _mm_add_ss(vLengthSq,vTemp); // y,y,y,y vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); // x+z+y,??,??,?? vLengthSq = _mm_add_ss(vLengthSq,vTemp); // Splat the length squared vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); // Get the length vLengthSq = _mm_sqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Length( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector3LengthSq(V); Result = XMVectorSqrt(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot3 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); const __n64 zero = vdup_n_u32(0); __n64 VEqualsZero = vceq_f32( v1, zero ); // Sqrt __n64 S0 = vrsqrte_f32( v1 ); __n64 P0 = vmul_f32( v1, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( v1, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 Result = vmul_f32( S1, R1 ); Result = vmul_f32( v1, Result ); Result = vbsl_f32( VEqualsZero, zero, Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y and z XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and y XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,2,1,2)); // x+z, y vLengthSq = _mm_add_ss(vLengthSq,vTemp); // y,y,y,y vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); // x+z+y,??,??,?? vLengthSq = _mm_add_ss(vLengthSq,vTemp); // Splat the length squared vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); // Get the length vLengthSq = _mm_sqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// XMVector3NormalizeEst uses a reciprocal estimate and// returns QNaN on zero and infinite vectors.inline XMVECTOR XMVector3NormalizeEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector3ReciprocalLength(V); Result = XMVectorMultiply(V, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot3 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); // Reciprocal sqrt (estimate) v2 = vrsqrte_f32( v1 ); // Normalize return vmulq_f32( V, vcombine_f32(v2,v2) );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product XMVECTOR vDot = _mm_mul_ps(V,V); // x=Dot.y, y=Dot.z XMVECTOR vTemp = XM_PERMUTE_PS(vDot,_MM_SHUFFLE(2,1,2,1)); // Result.x = x+y vDot = _mm_add_ss(vDot,vTemp); // x=Dot.z vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); // Result.x = (x+y)+z vDot = _mm_add_ss(vDot,vTemp); // Splat x vDot = XM_PERMUTE_PS(vDot,_MM_SHUFFLE(0,0,0,0)); // Get the reciprocal vDot = _mm_rsqrt_ps(vDot); // Perform the normalization vDot = _mm_mul_ps(vDot,V); return vDot;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Normalize( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) float fLength; XMVECTOR vResult; vResult = XMVector3Length( V ); fLength = vResult.vector4_f32[0]; // Prevent divide by zero if (fLength > 0) { fLength = 1.0f/fLength; } vResult.vector4_f32[0] = V.vector4_f32[0]*fLength; vResult.vector4_f32[1] = V.vector4_f32[1]*fLength; vResult.vector4_f32[2] = V.vector4_f32[2]*fLength; vResult.vector4_f32[3] = V.vector4_f32[3]*fLength; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot3 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vdup_lane_f32( v2, 0 ); v1 = vadd_f32( v1, v2 ); __n64 VEqualsZero = vceq_f32( v1, vdup_n_u32(0) ); __n64 VEqualsInf = vceq_f32( v1, vget_low_f32(g_XMInfinity) ); // Reciprocal sqrt (2 iterations of Newton-Raphson) __n64 S0 = vrsqrte_f32( v1 ); __n64 P0 = vmul_f32( v1, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( v1, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); v2 = vmul_f32( S1, R1 ); // Normalize __n128 vResult = vmulq_f32( V, vcombine_f32(v2,v2) ); vResult = vbslq_f32( vcombine_f32(VEqualsZero,VEqualsZero), vdupq_n_f32(0), vResult ); return vbslq_f32( vcombine_f32(VEqualsInf,VEqualsInf), g_XMQNaN, vResult );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y and z only XMVECTOR vLengthSq = _mm_mul_ps(V,V); XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,1,2,1)); vLengthSq = _mm_add_ss(vLengthSq,vTemp); vTemp = XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(1,1,1,1)); vLengthSq = _mm_add_ss(vLengthSq,vTemp); vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(0,0,0,0)); // Prepare for the division XMVECTOR vResult = _mm_sqrt_ps(vLengthSq); // Create zero with a single instruction XMVECTOR vZeroMask = _mm_setzero_ps(); // Test for a divide by zero (Must be FP to detect -0.0) vZeroMask = _mm_cmpneq_ps(vZeroMask,vResult); // Failsafe on zero (Or epsilon) length planes // If the length is infinity, set the elements to zero vLengthSq = _mm_cmpneq_ps(vLengthSq,g_XMInfinity); // Divide to perform the normalization vResult = _mm_div_ps(V,vResult); // Any that are infinity, set to zero vResult = _mm_and_ps(vResult,vZeroMask); // Select qnan or result based on infinite length XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq,g_XMQNaN); XMVECTOR vTemp2 = _mm_and_ps(vResult,vLengthSq); vResult = _mm_or_ps(vTemp1,vTemp2); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3ClampLength( FXMVECTOR V, float LengthMin, float LengthMax){ XMVECTOR ClampMax = XMVectorReplicate(LengthMax); XMVECTOR ClampMin = XMVectorReplicate(LengthMin); return XMVector3ClampLengthV(V, ClampMin, ClampMax);}//------------------------------------------------------------------------------inline XMVECTOR XMVector3ClampLengthV( FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax){ assert((XMVectorGetY(LengthMin) == XMVectorGetX(LengthMin)) && (XMVectorGetZ(LengthMin) == XMVectorGetX(LengthMin))); assert((XMVectorGetY(LengthMax) == XMVectorGetX(LengthMax)) && (XMVectorGetZ(LengthMax) == XMVectorGetX(LengthMax))); assert(XMVector3GreaterOrEqual(LengthMin, XMVectorZero())); assert(XMVector3GreaterOrEqual(LengthMax, XMVectorZero())); assert(XMVector3GreaterOrEqual(LengthMax, LengthMin)); XMVECTOR LengthSq = XMVector3LengthSq(V); const XMVECTOR Zero = XMVectorZero(); XMVECTOR RcpLength = XMVectorReciprocalSqrt(LengthSq); XMVECTOR InfiniteLength = XMVectorEqualInt(LengthSq, g_XMInfinity.v); XMVECTOR ZeroLength = XMVectorEqual(LengthSq, Zero); XMVECTOR Normal = XMVectorMultiply(V, RcpLength); XMVECTOR Length = XMVectorMultiply(LengthSq, RcpLength); XMVECTOR Select = XMVectorEqualInt(InfiniteLength, ZeroLength); Length = XMVectorSelect(LengthSq, Length, Select); Normal = XMVectorSelect(LengthSq, Normal, Select); XMVECTOR ControlMax = XMVectorGreater(Length, LengthMax); XMVECTOR ControlMin = XMVectorLess(Length, LengthMin); XMVECTOR ClampLength = XMVectorSelect(Length, LengthMax, ControlMax); ClampLength = XMVectorSelect(ClampLength, LengthMin, ControlMin); XMVECTOR Result = XMVectorMultiply(Normal, ClampLength); // Preserve the original vector (with no precision loss) if the length falls within the given range XMVECTOR Control = XMVectorEqualInt(ControlMax, ControlMin); Result = XMVectorSelect(Result, V, Control); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Reflect( FXMVECTOR Incident, FXMVECTOR Normal){ // Result = Incident - (2 * dot(Incident, Normal)) * Normal XMVECTOR Result = XMVector3Dot(Incident, Normal); Result = XMVectorAdd(Result, Result); Result = XMVectorNegativeMultiplySubtract(Result, Normal, Incident); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Refract( FXMVECTOR Incident, FXMVECTOR Normal, float RefractionIndex){ XMVECTOR Index = XMVectorReplicate(RefractionIndex); return XMVector3RefractV(Incident, Normal, Index);}//------------------------------------------------------------------------------inline XMVECTOR XMVector3RefractV( FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex){ // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) + // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal))))#if defined(_XM_NO_INTRINSICS_) const XMVECTOR Zero = XMVectorZero(); XMVECTOR IDotN = XMVector3Dot(Incident, Normal); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) XMVECTOR R = XMVectorNegativeMultiplySubtract(IDotN, IDotN, g_XMOne.v); R = XMVectorMultiply(R, RefractionIndex); R = XMVectorNegativeMultiplySubtract(R, RefractionIndex, g_XMOne.v); if (XMVector4LessOrEqual(R, Zero)) { // Total internal reflection return Zero; } else { // R = RefractionIndex * IDotN + sqrt(R) R = XMVectorSqrt(R); R = XMVectorMultiplyAdd(RefractionIndex, IDotN, R); // Result = RefractionIndex * Incident - Normal * R XMVECTOR Result = XMVectorMultiply(RefractionIndex, Incident); Result = XMVectorNegativeMultiplySubtract(Normal, R, Result); return Result; }#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR IDotN = XMVector3Dot(Incident,Normal); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) __n128 R = vmlsq_f32( g_XMOne, IDotN, IDotN); R = vmulq_f32(R, RefractionIndex); R = vmlsq_f32(g_XMOne, R, RefractionIndex ); __n128 vResult = vcleq_f32(R,g_XMZero); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); if ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU ) { // Total internal reflection vResult = g_XMZero; } else { // Sqrt(R) __n128 S0 = vrsqrteq_f32(R); __n128 P0 = vmulq_f32( R, S0 ); __n128 R0 = vrsqrtsq_f32( P0, S0 ); __n128 S1 = vmulq_f32( S0, R0 ); __n128 P1 = vmulq_f32( R, S1 ); __n128 R1 = vrsqrtsq_f32( P1, S1 ); __n128 S2 = vmulq_f32( S1, R1 ); R = vmulq_f32( R, S2 ); // R = RefractionIndex * IDotN + sqrt(R) R = vmlaq_f32( R, RefractionIndex, IDotN ); // Result = RefractionIndex * Incident - Normal * R vResult = vmulq_f32(RefractionIndex, Incident); vResult = vmlsq_f32( vResult, R, Normal ); } return vResult;#elif defined(_XM_SSE_INTRINSICS_) // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) + // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal)))) XMVECTOR IDotN = XMVector3Dot(Incident, Normal); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) XMVECTOR R = _mm_mul_ps(IDotN, IDotN); R = _mm_sub_ps(g_XMOne,R); R = _mm_mul_ps(R, RefractionIndex); R = _mm_mul_ps(R, RefractionIndex); R = _mm_sub_ps(g_XMOne,R); XMVECTOR vResult = _mm_cmple_ps(R,g_XMZero); if (_mm_movemask_ps(vResult)==0x0f) { // Total internal reflection vResult = g_XMZero; } else { // R = RefractionIndex * IDotN + sqrt(R) R = _mm_sqrt_ps(R); vResult = _mm_mul_ps(RefractionIndex,IDotN); R = _mm_add_ps(R,vResult); // Result = RefractionIndex * Incident - Normal * R vResult = _mm_mul_ps(RefractionIndex, Incident); R = _mm_mul_ps(R,Normal); vResult = _mm_sub_ps(vResult,R); } return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Orthogonal( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Zero = XMVectorZero(); XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR YZYY = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_Y>(V); XMVECTOR NegativeV = XMVectorSubtract(Zero, V); XMVECTOR ZIsNegative = XMVectorLess(Z, Zero); XMVECTOR YZYYIsNegative = XMVectorLess(YZYY, Zero); XMVECTOR S = XMVectorAdd(YZYY, Z); XMVECTOR D = XMVectorSubtract(YZYY, Z); XMVECTOR Select = XMVectorEqualInt(ZIsNegative, YZYYIsNegative); XMVECTOR R0 = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0X>(NegativeV, S); XMVECTOR R1 = XMVectorPermute<XM_PERMUTE_1X, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0X>(V, D); return XMVectorSelect(R1, R0, Select);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3AngleBetweenNormalsEst( FXMVECTOR N1, FXMVECTOR N2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Result = XMVector3Dot(N1, N2); Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v); Result = XMVectorACosEst(Result); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3AngleBetweenNormals( FXMVECTOR N1, FXMVECTOR N2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Result = XMVector3Dot(N1, N2); Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v); Result = XMVectorACos(Result); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3AngleBetweenVectors( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR L1 = XMVector3ReciprocalLength(V1); XMVECTOR L2 = XMVector3ReciprocalLength(V2); XMVECTOR Dot = XMVector3Dot(V1, V2); L1 = XMVectorMultiply(L1, L2); XMVECTOR CosAngle = XMVectorMultiply(Dot, L1); CosAngle = XMVectorClamp(CosAngle, g_XMNegativeOne.v, g_XMOne.v); return XMVectorACos(CosAngle);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3LinePointDistance( FXMVECTOR LinePoint1, FXMVECTOR LinePoint2, FXMVECTOR Point){ // Given a vector PointVector from LinePoint1 to Point and a vector // LineVector from LinePoint1 to LinePoint2, the scaled distance // PointProjectionScale from LinePoint1 to the perpendicular projection // of PointVector onto the line is defined as: // // PointProjectionScale = dot(PointVector, LineVector) / LengthSq(LineVector)#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR PointVector = XMVectorSubtract(Point, LinePoint1); XMVECTOR LineVector = XMVectorSubtract(LinePoint2, LinePoint1); XMVECTOR LengthSq = XMVector3LengthSq(LineVector); XMVECTOR PointProjectionScale = XMVector3Dot(PointVector, LineVector); PointProjectionScale = XMVectorDivide(PointProjectionScale, LengthSq); XMVECTOR DistanceVector = XMVectorMultiply(LineVector, PointProjectionScale); DistanceVector = XMVectorSubtract(PointVector, DistanceVector); return XMVector3Length(DistanceVector);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline void XMVector3ComponentsFromNormal( XMVECTOR* pParallel, XMVECTOR* pPerpendicular, FXMVECTOR V, FXMVECTOR Normal){ assert(pParallel != NULL); assert(pPerpendicular != NULL); XMVECTOR Scale = XMVector3Dot(V, Normal); XMVECTOR Parallel = XMVectorMultiply(Normal, Scale); *pParallel = Parallel; *pPerpendicular = XMVectorSubtract(V, Parallel);}//------------------------------------------------------------------------------// Transform a vector using a rotation expressed as a unit quaternioninline XMVECTOR XMVector3Rotate( FXMVECTOR V, FXMVECTOR RotationQuaternion){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR A = XMVectorSelect(g_XMSelect1110.v, V, g_XMSelect1110.v); XMVECTOR Q = XMQuaternionConjugate(RotationQuaternion); XMVECTOR Result = XMQuaternionMultiply(Q, A); return XMQuaternionMultiply(Result, RotationQuaternion);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Transform a vector using the inverse of a rotation expressed as a unit quaternioninline XMVECTOR XMVector3InverseRotate( FXMVECTOR V, FXMVECTOR RotationQuaternion){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR A = XMVectorSelect(g_XMSelect1110.v, V, g_XMSelect1110.v); XMVECTOR Result = XMQuaternionMultiply(RotationQuaternion, A); XMVECTOR Q = XMQuaternionConjugate(RotationQuaternion); return XMQuaternionMultiply(Result, Q);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Transform( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Z, M.r[2], M.r[3]); Result = XMVectorMultiplyAdd(Y, M.r[1], Result); Result = XMVectorMultiplyAdd(X, M.r[0], Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); XMVECTOR vResult = vdupq_lane_f32( VL, 0 ); // X XMVECTOR vTemp = vdupq_lane_f32( VL, 1 ); // Y vResult = vmlaq_f32( M.r[3], vResult, M.r[0] ); vResult = vmlaq_f32( vResult, vTemp, M.r[1] ); vTemp = vdupq_lane_f32( vget_high_f32( V ), 0 ); // Z return vmlaq_f32( vResult, vTemp, M.r[2] );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,0,0,0)); vResult = _mm_mul_ps(vResult,M.r[0]); XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); vTemp = _mm_mul_ps(vTemp,M.r[1]); vResult = _mm_add_ps(vResult,vTemp); vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2)); vTemp = _mm_mul_ps(vTemp,M.r[2]); vResult = _mm_add_ps(vResult,vTemp); vResult = _mm_add_ps(vResult,M.r[3]); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT4* XMVector3TransformStream( XMFLOAT4* pOutputStream, size_t OutputStride, const XMFLOAT3* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; const XMVECTOR row2 = M.r[2]; const XMVECTOR row3 = M.r[3]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector); XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Z, row2, row3); Result = XMVectorMultiplyAdd(Y, row1, Result); Result = XMVectorMultiplyAdd(X, row0, Result); XMStoreFloat4((XMFLOAT4*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3TransformCoord( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Z, M.r[2], M.r[3]); Result = XMVectorMultiplyAdd(Y, M.r[1], Result); Result = XMVectorMultiplyAdd(X, M.r[0], Result); XMVECTOR W = XMVectorSplatW(Result); return XMVectorDivide( Result, W );#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT3* XMVector3TransformCoordStream( XMFLOAT3* pOutputStream, size_t OutputStride, const XMFLOAT3* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; const XMVECTOR row2 = M.r[2]; const XMVECTOR row3 = M.r[3]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector); XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiplyAdd(Z, row2, row3); Result = XMVectorMultiplyAdd(Y, row1, Result); Result = XMVectorMultiplyAdd(X, row0, Result); XMVECTOR W = XMVectorSplatW(Result); Result = XMVectorDivide(Result, W); XMStoreFloat3((XMFLOAT3*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3TransformNormal( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiply(Z, M.r[2]); Result = XMVectorMultiplyAdd(Y, M.r[1], Result); Result = XMVectorMultiplyAdd(X, M.r[0], Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); XMVECTOR vResult = vdupq_lane_f32( VL, 0 ); // X XMVECTOR vTemp = vdupq_lane_f32( VL, 1 ); // Y vResult = vmulq_f32( vResult, M.r[0] ); vResult = vmlaq_f32( vResult, vTemp, M.r[1] ); vTemp = vdupq_lane_f32( vget_high_f32( V ), 0 ); // Z return vmlaq_f32( vResult, vTemp, M.r[2] );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,0,0,0)); vResult = _mm_mul_ps(vResult,M.r[0]); XMVECTOR vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); vTemp = _mm_mul_ps(vTemp,M.r[1]); vResult = _mm_add_ps(vResult,vTemp); vTemp = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2)); vTemp = _mm_mul_ps(vTemp,M.r[2]); vResult = _mm_add_ps(vResult,vTemp); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT3* XMVector3TransformNormalStream( XMFLOAT3* pOutputStream, size_t OutputStride, const XMFLOAT3* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; const XMVECTOR row2 = M.r[2]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector); XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiply(Z, row2); Result = XMVectorMultiplyAdd(Y, row1, Result); Result = XMVectorMultiplyAdd(X, row0, Result); XMStoreFloat3((XMFLOAT3*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Project( FXMVECTOR V, float ViewportX, float ViewportY, float ViewportWidth, float ViewportHeight, float ViewportMinZ, float ViewportMaxZ, CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) const float HalfViewportWidth = ViewportWidth * 0.5f; const float HalfViewportHeight = ViewportHeight * 0.5f; XMVECTOR Scale = XMVectorSet(HalfViewportWidth, -HalfViewportHeight, ViewportMaxZ - ViewportMinZ, 0.0f); XMVECTOR Offset = XMVectorSet(ViewportX + HalfViewportWidth, ViewportY + HalfViewportHeight, ViewportMinZ, 0.0f); XMMATRIX Transform = XMMatrixMultiply(World, View); Transform = XMMatrixMultiply(Transform, Projection); XMVECTOR Result = XMVector3TransformCoord(V, Transform); Result = XMVectorMultiplyAdd(Result, Scale, Offset); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT3* XMVector3ProjectStream( XMFLOAT3* pOutputStream, size_t OutputStride, const XMFLOAT3* pInputStream, size_t InputStride, size_t VectorCount, float ViewportX, float ViewportY, float ViewportWidth, float ViewportHeight, float ViewportMinZ, float ViewportMaxZ, CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) const float HalfViewportWidth = ViewportWidth * 0.5f; const float HalfViewportHeight = ViewportHeight * 0.5f; XMVECTOR Scale = XMVectorSet(HalfViewportWidth, -HalfViewportHeight, ViewportMaxZ - ViewportMinZ, 1.0f); XMVECTOR Offset = XMVectorSet(ViewportX + HalfViewportWidth, ViewportY + HalfViewportHeight, ViewportMinZ, 0.0f); XMMATRIX Transform = XMMatrixMultiply(World, View); Transform = XMMatrixMultiply(Transform, Projection); const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector); XMVECTOR Result = XMVector3TransformCoord(V, Transform); Result = XMVectorMultiplyAdd(Result, Scale, Offset); XMStoreFloat3((XMFLOAT3*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector3Unproject( FXMVECTOR V, float ViewportX, float ViewportY, float ViewportWidth, float ViewportHeight, float ViewportMinZ, float ViewportMaxZ, CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 D = { -1.0f, 1.0f, 0.0f, 0.0f }; XMVECTOR Scale = XMVectorSet(ViewportWidth * 0.5f, -ViewportHeight * 0.5f, ViewportMaxZ - ViewportMinZ, 1.0f); Scale = XMVectorReciprocal(Scale); XMVECTOR Offset = XMVectorSet(-ViewportX, -ViewportY, -ViewportMinZ, 0.0f); Offset = XMVectorMultiplyAdd(Scale, Offset, D.v); XMMATRIX Transform = XMMatrixMultiply(World, View); Transform = XMMatrixMultiply(Transform, Projection); Transform = XMMatrixInverse(NULL, Transform); XMVECTOR Result = XMVectorMultiplyAdd(V, Scale, Offset); return XMVector3TransformCoord(Result, Transform);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT3* XMVector3UnprojectStream( XMFLOAT3* pOutputStream, size_t OutputStride, const XMFLOAT3* pInputStream, size_t InputStride, size_t VectorCount, float ViewportX, float ViewportY, float ViewportWidth, float ViewportHeight, float ViewportMinZ, float ViewportMaxZ, CXMMATRIX Projection, CXMMATRIX View, CXMMATRIX World){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) || defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 D = { -1.0f, 1.0f, 0.0f, 0.0f }; XMVECTOR Scale = XMVectorSet(ViewportWidth * 0.5f, -ViewportHeight * 0.5f, ViewportMaxZ - ViewportMinZ, 1.0f); Scale = XMVectorReciprocal(Scale); XMVECTOR Offset = XMVectorSet(-ViewportX, -ViewportY, -ViewportMinZ, 0.0f); Offset = XMVectorMultiplyAdd(Scale, Offset, D.v); XMMATRIX Transform = XMMatrixMultiply(World, View); Transform = XMMatrixMultiply(Transform, Projection); Transform = XMMatrixInverse(NULL, Transform); const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector); XMVECTOR Result = XMVectorMultiplyAdd(V, Scale, Offset); Result = XMVector3TransformCoord(Result, Transform); XMStoreFloat3((XMFLOAT3*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}/**************************************************************************** * * 4D Vector * ****************************************************************************///------------------------------------------------------------------------------// Comparison operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline bool XMVector4Equal( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1]) && (V1.vector4_f32[2] == V2.vector4_f32[2]) && (V1.vector4_f32[3] == V2.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2); return ((_mm_movemask_ps(vTemp)==0x0f) != 0);#else return XMComparisonAllTrue(XMVector4EqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector4EqualR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] == V2.vector4_f32[0]) && (V1.vector4_f32[1] == V2.vector4_f32[1]) && (V1.vector4_f32[2] == V2.vector4_f32[2]) && (V1.vector4_f32[3] == V2.vector4_f32[3])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] != V2.vector4_f32[0]) && (V1.vector4_f32[1] != V2.vector4_f32[1]) && (V1.vector4_f32[2] != V2.vector4_f32[2]) && (V1.vector4_f32[3] != V2.vector4_f32[3])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpeq_ps(V1,V2); int iTest = _mm_movemask_ps(vTemp); uint32_t CR = 0; if (iTest==0xf) // All equal? { CR = XM_CRMASK_CR6TRUE; } else if (iTest==0) // All not equal? { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector4EqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_u32[0] == V2.vector4_u32[0]) && (V1.vector4_u32[1] == V2.vector4_u32[1]) && (V1.vector4_u32[2] == V2.vector4_u32[2]) && (V1.vector4_u32[3] == V2.vector4_u32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); return ((_mm_movemask_ps(_mm_castsi128_ps(vTemp))==0xf) != 0);#else return XMComparisonAllTrue(XMVector4EqualIntR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector4EqualIntR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if (V1.vector4_u32[0] == V2.vector4_u32[0] && V1.vector4_u32[1] == V2.vector4_u32[1] && V1.vector4_u32[2] == V2.vector4_u32[2] && V1.vector4_u32[3] == V2.vector4_u32[3]) { CR = XM_CRMASK_CR6TRUE; } else if (V1.vector4_u32[0] != V2.vector4_u32[0] && V1.vector4_u32[1] != V2.vector4_u32[1] && V1.vector4_u32[2] != V2.vector4_u32[2] && V1.vector4_u32[3] != V2.vector4_u32[3]) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); int iTest = _mm_movemask_ps(_mm_castsi128_ps(vTemp)); uint32_t CR = 0; if (iTest==0xf) // All equal? { CR = XM_CRMASK_CR6TRUE; } else if (iTest==0) // All not equal? { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}inline bool XMVector4NearEqual( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR Epsilon){#if defined(_XM_NO_INTRINSICS_) float dx, dy, dz, dw; dx = fabsf(V1.vector4_f32[0]-V2.vector4_f32[0]); dy = fabsf(V1.vector4_f32[1]-V2.vector4_f32[1]); dz = fabsf(V1.vector4_f32[2]-V2.vector4_f32[2]); dw = fabsf(V1.vector4_f32[3]-V2.vector4_f32[3]); return (((dx <= Epsilon.vector4_f32[0]) && (dy <= Epsilon.vector4_f32[1]) && (dz <= Epsilon.vector4_f32[2]) && (dw <= Epsilon.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vDelta = vsubq_f32( V1, V2 ); __n128 vResult = vacleq_f32( vDelta, Epsilon ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Get the difference XMVECTOR vDelta = _mm_sub_ps(V1,V2); // Get the absolute value of the difference XMVECTOR vTemp = _mm_setzero_ps(); vTemp = _mm_sub_ps(vTemp,vDelta); vTemp = _mm_max_ps(vTemp,vDelta); vTemp = _mm_cmple_ps(vTemp,Epsilon); return ((_mm_movemask_ps(vTemp)==0xf) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector4NotEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] != V2.vector4_f32[0]) || (V1.vector4_f32[1] != V2.vector4_f32[1]) || (V1.vector4_f32[2] != V2.vector4_f32[2]) || (V1.vector4_f32[3] != V2.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) != 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpneq_ps(V1,V2); return ((_mm_movemask_ps(vTemp)) != 0);#else return XMComparisonAnyFalse(XMVector4EqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline bool XMVector4NotEqualInt( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_u32[0] != V2.vector4_u32[0]) || (V1.vector4_u32[1] != V2.vector4_u32[1]) || (V1.vector4_u32[2] != V2.vector4_u32[2]) || (V1.vector4_u32[3] != V2.vector4_u32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vceqq_u32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) != 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) __m128i vTemp = _mm_cmpeq_epi32(_mm_castps_si128(V1),_mm_castps_si128(V2)); return ((_mm_movemask_ps(_mm_castsi128_ps(vTemp))!=0xF) != 0);#else return XMComparisonAnyFalse(XMVector4EqualIntR(V1, V2));#endif}//------------------------------------------------------------------------------inline bool XMVector4Greater( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] > V2.vector4_f32[0]) && (V1.vector4_f32[1] > V2.vector4_f32[1]) && (V1.vector4_f32[2] > V2.vector4_f32[2]) && (V1.vector4_f32[3] > V2.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgtq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2); return ((_mm_movemask_ps(vTemp)==0x0f) != 0);#else return XMComparisonAllTrue(XMVector4GreaterR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector4GreaterR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if (V1.vector4_f32[0] > V2.vector4_f32[0] && V1.vector4_f32[1] > V2.vector4_f32[1] && V1.vector4_f32[2] > V2.vector4_f32[2] && V1.vector4_f32[3] > V2.vector4_f32[3]) { CR = XM_CRMASK_CR6TRUE; } else if (V1.vector4_f32[0] <= V2.vector4_f32[0] && V1.vector4_f32[1] <= V2.vector4_f32[1] && V1.vector4_f32[2] <= V2.vector4_f32[2] && V1.vector4_f32[3] <= V2.vector4_f32[3]) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgtq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) uint32_t CR = 0; XMVECTOR vTemp = _mm_cmpgt_ps(V1,V2); int iTest = _mm_movemask_ps(vTemp); if (iTest==0xf) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector4GreaterOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1]) && (V1.vector4_f32[2] >= V2.vector4_f32[2]) && (V1.vector4_f32[3] >= V2.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgeq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); return ((_mm_movemask_ps(vTemp)==0x0f) != 0);#else return XMComparisonAllTrue(XMVector4GreaterOrEqualR(V1, V2));#endif}//------------------------------------------------------------------------------inline uint32_t XMVector4GreaterOrEqualR( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) uint32_t CR = 0; if ((V1.vector4_f32[0] >= V2.vector4_f32[0]) && (V1.vector4_f32[1] >= V2.vector4_f32[1]) && (V1.vector4_f32[2] >= V2.vector4_f32[2]) && (V1.vector4_f32[3] >= V2.vector4_f32[3])) { CR = XM_CRMASK_CR6TRUE; } else if ((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1]) && (V1.vector4_f32[2] < V2.vector4_f32[2]) && (V1.vector4_f32[3] < V2.vector4_f32[3])) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcgeq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); uint32_t r = vget_lane_u32(vTemp.val[1], 1); uint32_t CR = 0; if ( r == 0xFFFFFFFFU ) { CR = XM_CRMASK_CR6TRUE; } else if ( !r ) { CR = XM_CRMASK_CR6FALSE; } return CR;#elif defined(_XM_SSE_INTRINSICS_) uint32_t CR = 0; XMVECTOR vTemp = _mm_cmpge_ps(V1,V2); int iTest = _mm_movemask_ps(vTemp); if (iTest==0x0f) { CR = XM_CRMASK_CR6TRUE; } else if (!iTest) { CR = XM_CRMASK_CR6FALSE; } return CR;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector4Less( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] < V2.vector4_f32[0]) && (V1.vector4_f32[1] < V2.vector4_f32[1]) && (V1.vector4_f32[2] < V2.vector4_f32[2]) && (V1.vector4_f32[3] < V2.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcltq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmplt_ps(V1,V2); return ((_mm_movemask_ps(vTemp)==0x0f) != 0);#else return XMComparisonAllTrue(XMVector4GreaterR(V2, V1));#endif}//------------------------------------------------------------------------------inline bool XMVector4LessOrEqual( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) return (((V1.vector4_f32[0] <= V2.vector4_f32[0]) && (V1.vector4_f32[1] <= V2.vector4_f32[1]) && (V1.vector4_f32[2] <= V2.vector4_f32[2]) && (V1.vector4_f32[3] <= V2.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vResult = vcleq_f32( V1, V2 ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp = _mm_cmple_ps(V1,V2); return ((_mm_movemask_ps(vTemp)==0x0f) != 0);#else return XMComparisonAllTrue(XMVector4GreaterOrEqualR(V2, V1));#endif}//------------------------------------------------------------------------------inline bool XMVector4InBounds( FXMVECTOR V, FXMVECTOR Bounds){#if defined(_XM_NO_INTRINSICS_) return (((V.vector4_f32[0] <= Bounds.vector4_f32[0] && V.vector4_f32[0] >= -Bounds.vector4_f32[0]) && (V.vector4_f32[1] <= Bounds.vector4_f32[1] && V.vector4_f32[1] >= -Bounds.vector4_f32[1]) && (V.vector4_f32[2] <= Bounds.vector4_f32[2] && V.vector4_f32[2] >= -Bounds.vector4_f32[2]) && (V.vector4_f32[3] <= Bounds.vector4_f32[3] && V.vector4_f32[3] >= -Bounds.vector4_f32[3])) != 0);#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test if less than or equal __n128 vTemp1 = vcleq_f32(V,Bounds); // Negate the bounds __n128 vTemp2 = vnegq_f32(Bounds); // Test if greater or equal (Reversed) vTemp2 = vcleq_f32(vTemp2,V); // Blend answers vTemp1 = vandq_u32(vTemp1,vTemp2); // in bounds? int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTemp1), vget_high_u8(vTemp1)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Test if less than or equal XMVECTOR vTemp1 = _mm_cmple_ps(V,Bounds); // Negate the bounds XMVECTOR vTemp2 = _mm_mul_ps(Bounds,g_XMNegativeOne); // Test if greater or equal (Reversed) vTemp2 = _mm_cmple_ps(vTemp2,V); // Blend answers vTemp1 = _mm_and_ps(vTemp1,vTemp2); // All in bounds? return ((_mm_movemask_ps(vTemp1)==0x0f) != 0);#else return XMComparisonAllInBounds(XMVector4InBoundsR(V, Bounds));#endif}//------------------------------------------------------------------------------inline bool XMVector4IsNaN( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return (XMISNAN(V.vector4_f32[0]) || XMISNAN(V.vector4_f32[1]) || XMISNAN(V.vector4_f32[2]) || XMISNAN(V.vector4_f32[3]));#elif defined(_XM_ARM_NEON_INTRINSICS_) // Test against itself. NaN is always not equal __n128 vTempNan = vceqq_f32( V, V ); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTempNan), vget_high_u8(vTempNan)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); // If any are NaN, the mask is zero return ( vget_lane_u32(vTemp.val[1], 1) != 0xFFFFFFFFU );#elif defined(_XM_SSE_INTRINSICS_) // Test against itself. NaN is always not equal XMVECTOR vTempNan = _mm_cmpneq_ps(V,V); // If any are NaN, the mask is non-zero return (_mm_movemask_ps(vTempNan)!=0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline bool XMVector4IsInfinite( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) return (XMISINF(V.vector4_f32[0]) || XMISINF(V.vector4_f32[1]) || XMISINF(V.vector4_f32[2]) || XMISINF(V.vector4_f32[3]));#elif defined(_XM_ARM_NEON_INTRINSICS_) // Mask off the sign bit __n128 vTempInf = vandq_u32( V, g_XMAbsMask ); // Compare to infinity vTempInf = vceqq_f32(vTempInf, g_XMInfinity ); // If any are infinity, the signs are true. int8x8x2_t vTemp = vzip_u8(vget_low_u8(vTempInf), vget_high_u8(vTempInf)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); return ( vget_lane_u32(vTemp.val[1], 1) != 0 );#elif defined(_XM_SSE_INTRINSICS_) // Mask off the sign bit XMVECTOR vTemp = _mm_and_ps(V,g_XMAbsMask); // Compare to infinity vTemp = _mm_cmpeq_ps(vTemp,g_XMInfinity); // If any are infinity, the signs are true. return (_mm_movemask_ps(vTemp) != 0);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// Computation operations//------------------------------------------------------------------------------//------------------------------------------------------------------------------inline XMVECTOR XMVector4Dot( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = Result.vector4_f32[1] = Result.vector4_f32[2] = Result.vector4_f32[3] = V1.vector4_f32[0] * V2.vector4_f32[0] + V1.vector4_f32[1] * V2.vector4_f32[1] + V1.vector4_f32[2] * V2.vector4_f32[2] + V1.vector4_f32[3] * V2.vector4_f32[3]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n128 vTemp = vmulq_f32( V1, V2 ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); return vcombine_f32( v1, v1 );#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR vTemp2 = V2; XMVECTOR vTemp = _mm_mul_ps(V1,vTemp2); vTemp2 = _mm_shuffle_ps(vTemp2,vTemp,_MM_SHUFFLE(1,0,0,0)); // Copy X to the Z position and Y to the W position vTemp2 = _mm_add_ps(vTemp2,vTemp); // Add Z = X+Z; W = Y+W; vTemp = _mm_shuffle_ps(vTemp,vTemp2,_MM_SHUFFLE(0,3,0,0)); // Copy W to the Z position vTemp = _mm_add_ps(vTemp,vTemp2); // Add Z and W together return XM_PERMUTE_PS(vTemp,_MM_SHUFFLE(2,2,2,2)); // Splat Z and return#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Cross( FXMVECTOR V1, FXMVECTOR V2, FXMVECTOR V3){ // [ ((v2.z*v3.w-v2.w*v3.z)*v1.y)-((v2.y*v3.w-v2.w*v3.y)*v1.z)+((v2.y*v3.z-v2.z*v3.y)*v1.w), // ((v2.w*v3.z-v2.z*v3.w)*v1.x)-((v2.w*v3.x-v2.x*v3.w)*v1.z)+((v2.z*v3.x-v2.x*v3.z)*v1.w), // ((v2.y*v3.w-v2.w*v3.y)*v1.x)-((v2.x*v3.w-v2.w*v3.x)*v1.y)+((v2.x*v3.y-v2.y*v3.x)*v1.w), // ((v2.z*v3.y-v2.y*v3.z)*v1.x)-((v2.z*v3.x-v2.x*v3.z)*v1.y)+((v2.y*v3.x-v2.x*v3.y)*v1.z) ]#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = (((V2.vector4_f32[2]*V3.vector4_f32[3])-(V2.vector4_f32[3]*V3.vector4_f32[2]))*V1.vector4_f32[1])-(((V2.vector4_f32[1]*V3.vector4_f32[3])-(V2.vector4_f32[3]*V3.vector4_f32[1]))*V1.vector4_f32[2])+(((V2.vector4_f32[1]*V3.vector4_f32[2])-(V2.vector4_f32[2]*V3.vector4_f32[1]))*V1.vector4_f32[3]); Result.vector4_f32[1] = (((V2.vector4_f32[3]*V3.vector4_f32[2])-(V2.vector4_f32[2]*V3.vector4_f32[3]))*V1.vector4_f32[0])-(((V2.vector4_f32[3]*V3.vector4_f32[0])-(V2.vector4_f32[0]*V3.vector4_f32[3]))*V1.vector4_f32[2])+(((V2.vector4_f32[2]*V3.vector4_f32[0])-(V2.vector4_f32[0]*V3.vector4_f32[2]))*V1.vector4_f32[3]); Result.vector4_f32[2] = (((V2.vector4_f32[1]*V3.vector4_f32[3])-(V2.vector4_f32[3]*V3.vector4_f32[1]))*V1.vector4_f32[0])-(((V2.vector4_f32[0]*V3.vector4_f32[3])-(V2.vector4_f32[3]*V3.vector4_f32[0]))*V1.vector4_f32[1])+(((V2.vector4_f32[0]*V3.vector4_f32[1])-(V2.vector4_f32[1]*V3.vector4_f32[0]))*V1.vector4_f32[3]); Result.vector4_f32[3] = (((V2.vector4_f32[2]*V3.vector4_f32[1])-(V2.vector4_f32[1]*V3.vector4_f32[2]))*V1.vector4_f32[0])-(((V2.vector4_f32[2]*V3.vector4_f32[0])-(V2.vector4_f32[0]*V3.vector4_f32[2]))*V1.vector4_f32[1])+(((V2.vector4_f32[1]*V3.vector4_f32[0])-(V2.vector4_f32[0]*V3.vector4_f32[1]))*V1.vector4_f32[2]); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) const __n64 select = vget_low_f32( g_XMMaskX ); // Term1: V2zwyz * V3wzwy const __n64 v2xy = vget_low_f32(V2); const __n64 v2zw = vget_high_f32(V2); const __n64 v2yx = vrev64_f32(v2xy); const __n64 v2wz = vrev64_f32(v2zw); const __n64 v2yz = vbsl_f32( select, v2yx, v2wz ); const __n64 v3zw = vget_high_f32(V3); const __n64 v3wz = vrev64_f32(v3zw); const __n64 v3xy = vget_low_f32(V3); const __n64 v3wy = vbsl_f32( select, v3wz, v3xy ); __n128 vTemp1 = vcombine_f32(v2zw,v2yz); __n128 vTemp2 = vcombine_f32(v3wz,v3wy); __n128 vResult = vmulq_f32( vTemp1, vTemp2 ); // - V2wzwy * V3zwyz const __n64 v2wy = vbsl_f32( select, v2wz, v2xy ); const __n64 v3yx = vrev64_f32(v3xy); const __n64 v3yz = vbsl_f32( select, v3yx, v3wz ); vTemp1 = vcombine_f32(v2wz,v2wy); vTemp2 = vcombine_f32(v3zw,v3yz); vResult = vmlsq_f32( vResult, vTemp1, vTemp2 ); // term1 * V1yxxx const __n64 v1xy = vget_low_f32(V1); const __n64 v1yx = vrev64_f32(v1xy); vTemp1 = vcombine_f32( v1yx, vdup_lane_f32( v1yx, 1 ) ); vResult = vmulq_f32( vResult, vTemp1 ); // Term2: V2ywxz * V3wxwx const __n64 v2yw = vrev64_f32(v2wy); const __n64 v2xz = vbsl_f32( select, v2xy, v2wz ); const __n64 v3wx = vbsl_f32( select, v3wz, v3yx ); vTemp1 = vcombine_f32(v2yw,v2xz); vTemp2 = vcombine_f32(v3wx,v3wx); __n128 vTerm = vmulq_f32( vTemp1, vTemp2 ); // - V2wxwx * V3ywxz const __n64 v2wx = vbsl_f32( select, v2wz, v2yx ); const __n64 v3yw = vrev64_f32(v3wy); const __n64 v3xz = vbsl_f32( select, v3xy, v3wz ); vTemp1 = vcombine_f32(v2wx,v2wx); vTemp2 = vcombine_f32(v3yw,v3xz); vTerm = vmlsq_f32( vTerm, vTemp1, vTemp2 ); // vResult - term2 * V1zzyy const __n64 v1zw = vget_high_f32(V1); vTemp1 = vcombine_f32( vdup_lane_f32(v1zw, 0), vdup_lane_f32(v1yx, 0) ); vResult = vmlsq_f32( vResult, vTerm, vTemp1 ); // Term3: V2yzxy * V3zxyx const __n64 v3zx = vrev64_f32(v3xz); vTemp1 = vcombine_f32(v2yz,v2xy); vTemp2 = vcombine_f32(v3zx,v3yx); vTerm = vmulq_f32( vTemp1, vTemp2 ); // - V2zxyx * V3yzxy const __n64 v2zx = vrev64_f32(v2xz); vTemp1 = vcombine_f32(v2zx,v2yx); vTemp2 = vcombine_f32(v3yz,v3xy); vTerm = vmlsq_f32( vTerm, vTemp1, vTemp2 ); // vResult + term3 * V1wwwz const __n64 v1wz = vrev64_f32(v1zw); vTemp1 = vcombine_f32( vdup_lane_f32( v1wz, 0 ), v1wz ); return vmlaq_f32( vResult, vTerm, vTemp1 );#elif defined(_XM_SSE_INTRINSICS_) // V2zwyz * V3wzwy XMVECTOR vResult = XM_PERMUTE_PS(V2,_MM_SHUFFLE(2,1,3,2)); XMVECTOR vTemp3 = XM_PERMUTE_PS(V3,_MM_SHUFFLE(1,3,2,3)); vResult = _mm_mul_ps(vResult,vTemp3); // - V2wzwy * V3zwyz XMVECTOR vTemp2 = XM_PERMUTE_PS(V2,_MM_SHUFFLE(1,3,2,3)); vTemp3 = XM_PERMUTE_PS(vTemp3,_MM_SHUFFLE(1,3,0,1)); vTemp2 = _mm_mul_ps(vTemp2,vTemp3); vResult = _mm_sub_ps(vResult,vTemp2); // term1 * V1yxxx XMVECTOR vTemp1 = XM_PERMUTE_PS(V1,_MM_SHUFFLE(0,0,0,1)); vResult = _mm_mul_ps(vResult,vTemp1); // V2ywxz * V3wxwx vTemp2 = XM_PERMUTE_PS(V2,_MM_SHUFFLE(2,0,3,1)); vTemp3 = XM_PERMUTE_PS(V3,_MM_SHUFFLE(0,3,0,3)); vTemp3 = _mm_mul_ps(vTemp3,vTemp2); // - V2wxwx * V3ywxz vTemp2 = XM_PERMUTE_PS(vTemp2,_MM_SHUFFLE(2,1,2,1)); vTemp1 = XM_PERMUTE_PS(V3,_MM_SHUFFLE(2,0,3,1)); vTemp2 = _mm_mul_ps(vTemp2,vTemp1); vTemp3 = _mm_sub_ps(vTemp3,vTemp2); // vResult - temp * V1zzyy vTemp1 = XM_PERMUTE_PS(V1,_MM_SHUFFLE(1,1,2,2)); vTemp1 = _mm_mul_ps(vTemp1,vTemp3); vResult = _mm_sub_ps(vResult,vTemp1); // V2yzxy * V3zxyx vTemp2 = XM_PERMUTE_PS(V2,_MM_SHUFFLE(1,0,2,1)); vTemp3 = XM_PERMUTE_PS(V3,_MM_SHUFFLE(0,1,0,2)); vTemp3 = _mm_mul_ps(vTemp3,vTemp2); // - V2zxyx * V3yzxy vTemp2 = XM_PERMUTE_PS(vTemp2,_MM_SHUFFLE(2,0,2,1)); vTemp1 = XM_PERMUTE_PS(V3,_MM_SHUFFLE(1,0,2,1)); vTemp1 = _mm_mul_ps(vTemp1,vTemp2); vTemp3 = _mm_sub_ps(vTemp3,vTemp1); // vResult + term * V1wwwz vTemp1 = XM_PERMUTE_PS(V1,_MM_SHUFFLE(2,3,3,3)); vTemp3 = _mm_mul_ps(vTemp3,vTemp1); vResult = _mm_add_ps(vResult,vTemp3); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4LengthSq( FXMVECTOR V){ return XMVector4Dot(V, V);}//------------------------------------------------------------------------------inline XMVECTOR XMVector4ReciprocalLengthEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector4LengthSq(V); Result = XMVectorReciprocalSqrtEst(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot4 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); // Reciprocal sqrt (estimate) v2 = vrsqrte_f32( v1 ); return vcombine_f32(v2, v2);#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y,z and w XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and w XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(3,2,3,2)); // x+z, y+w vLengthSq = _mm_add_ps(vLengthSq,vTemp); // x+z,x+z,x+z,y+w vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,0,0,0)); // ??,??,y+w,y+w vTemp = _mm_shuffle_ps(vTemp,vLengthSq,_MM_SHUFFLE(3,3,0,0)); // ??,??,x+z+y+w,?? vLengthSq = _mm_add_ps(vLengthSq,vTemp); // Splat the length vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,2,2,2)); // Get the reciprocal vLengthSq = _mm_rsqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4ReciprocalLength( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector4LengthSq(V); Result = XMVectorReciprocalSqrt(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot4 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); // Reciprocal sqrt __n64 S0 = vrsqrte_f32(v1); __n64 P0 = vmul_f32( v1, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( v1, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 Result = vmul_f32( S1, R1 ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y,z and w XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and w XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(3,2,3,2)); // x+z, y+w vLengthSq = _mm_add_ps(vLengthSq,vTemp); // x+z,x+z,x+z,y+w vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,0,0,0)); // ??,??,y+w,y+w vTemp = _mm_shuffle_ps(vTemp,vLengthSq,_MM_SHUFFLE(3,3,0,0)); // ??,??,x+z+y+w,?? vLengthSq = _mm_add_ps(vLengthSq,vTemp); // Splat the length vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,2,2,2)); // Get the reciprocal vLengthSq = _mm_sqrt_ps(vLengthSq); // Accurate! vLengthSq = _mm_div_ps(g_XMOne,vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4LengthEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector4LengthSq(V); Result = XMVectorSqrtEst(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot4 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); const __n64 zero = vdup_n_u32(0); __n64 VEqualsZero = vceq_f32( v1, zero ); // Sqrt (estimate) __n64 Result = vrsqrte_f32( v1 ); Result = vmul_f32( v1, Result ); Result = vbsl_f32( VEqualsZero, zero, Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y,z and w XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and w XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(3,2,3,2)); // x+z, y+w vLengthSq = _mm_add_ps(vLengthSq,vTemp); // x+z,x+z,x+z,y+w vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,0,0,0)); // ??,??,y+w,y+w vTemp = _mm_shuffle_ps(vTemp,vLengthSq,_MM_SHUFFLE(3,3,0,0)); // ??,??,x+z+y+w,?? vLengthSq = _mm_add_ps(vLengthSq,vTemp); // Splat the length vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,2,2,2)); // Prepare for the division vLengthSq = _mm_sqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Length( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector4LengthSq(V); Result = XMVectorSqrt(Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot4 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); const __n64 zero = vdup_n_u32(0); __n64 VEqualsZero = vceq_f32( v1, zero ); // Sqrt __n64 S0 = vrsqrte_f32( v1 ); __n64 P0 = vmul_f32( v1, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( v1, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); __n64 Result = vmul_f32( S1, R1 ); Result = vmul_f32( v1, Result ); Result = vbsl_f32( VEqualsZero, zero, Result ); return vcombine_f32( Result, Result );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y,z and w XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and w XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(3,2,3,2)); // x+z, y+w vLengthSq = _mm_add_ps(vLengthSq,vTemp); // x+z,x+z,x+z,y+w vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,0,0,0)); // ??,??,y+w,y+w vTemp = _mm_shuffle_ps(vTemp,vLengthSq,_MM_SHUFFLE(3,3,0,0)); // ??,??,x+z+y+w,?? vLengthSq = _mm_add_ps(vLengthSq,vTemp); // Splat the length vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,2,2,2)); // Prepare for the division vLengthSq = _mm_sqrt_ps(vLengthSq); return vLengthSq;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------// XMVector4NormalizeEst uses a reciprocal estimate and// returns QNaN on zero and infinite vectors.inline XMVECTOR XMVector4NormalizeEst( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result = XMVector4ReciprocalLength(V); Result = XMVectorMultiply(V, Result); return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot4 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); // Reciprocal sqrt (estimate) v2 = vrsqrte_f32( v1 ); // Normalize return vmulq_f32( V, vcombine_f32(v2,v2) );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y,z and w XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and w XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(3,2,3,2)); // x+z, y+w vLengthSq = _mm_add_ps(vLengthSq,vTemp); // x+z,x+z,x+z,y+w vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,0,0,0)); // ??,??,y+w,y+w vTemp = _mm_shuffle_ps(vTemp,vLengthSq,_MM_SHUFFLE(3,3,0,0)); // ??,??,x+z+y+w,?? vLengthSq = _mm_add_ps(vLengthSq,vTemp); // Splat the length vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,2,2,2)); // Get the reciprocal XMVECTOR vResult = _mm_rsqrt_ps(vLengthSq); // Reciprocal mul to perform the normalization vResult = _mm_mul_ps(vResult,V); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Normalize( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) float fLength; XMVECTOR vResult; vResult = XMVector4Length( V ); fLength = vResult.vector4_f32[0]; // Prevent divide by zero if (fLength > 0) { fLength = 1.0f/fLength; } vResult.vector4_f32[0] = V.vector4_f32[0]*fLength; vResult.vector4_f32[1] = V.vector4_f32[1]*fLength; vResult.vector4_f32[2] = V.vector4_f32[2]*fLength; vResult.vector4_f32[3] = V.vector4_f32[3]*fLength; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) // Dot4 __n128 vTemp = vmulq_f32( V, V ); __n64 v1 = vget_low_f32( vTemp ); __n64 v2 = vget_high_f32( vTemp ); v1 = vpadd_f32( v1, v1 ); v2 = vpadd_f32( v2, v2 ); v1 = vadd_f32( v1, v2 ); __n64 VEqualsZero = vceq_f32( v1, vdup_n_u32(0) ); __n64 VEqualsInf = vceq_f32( v1, vget_low_f32(g_XMInfinity) ); // Reciprocal sqrt (2 iterations of Newton-Raphson) __n64 S0 = vrsqrte_f32( v1 ); __n64 P0 = vmul_f32( v1, S0 ); __n64 R0 = vrsqrts_f32( P0, S0 ); __n64 S1 = vmul_f32( S0, R0 ); __n64 P1 = vmul_f32( v1, S1 ); __n64 R1 = vrsqrts_f32( P1, S1 ); v2 = vmul_f32( S1, R1 ); // Normalize __n128 vResult = vmulq_f32( V, vcombine_f32(v2,v2) ); vResult = vbslq_f32( vcombine_f32(VEqualsZero,VEqualsZero), vdupq_n_f32(0), vResult ); return vbslq_f32( vcombine_f32(VEqualsInf,VEqualsInf), g_XMQNaN, vResult );#elif defined(_XM_SSE_INTRINSICS_) // Perform the dot product on x,y,z and w XMVECTOR vLengthSq = _mm_mul_ps(V,V); // vTemp has z and w XMVECTOR vTemp = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(3,2,3,2)); // x+z, y+w vLengthSq = _mm_add_ps(vLengthSq,vTemp); // x+z,x+z,x+z,y+w vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(1,0,0,0)); // ??,??,y+w,y+w vTemp = _mm_shuffle_ps(vTemp,vLengthSq,_MM_SHUFFLE(3,3,0,0)); // ??,??,x+z+y+w,?? vLengthSq = _mm_add_ps(vLengthSq,vTemp); // Splat the length vLengthSq = XM_PERMUTE_PS(vLengthSq,_MM_SHUFFLE(2,2,2,2)); // Prepare for the division XMVECTOR vResult = _mm_sqrt_ps(vLengthSq); // Create zero with a single instruction XMVECTOR vZeroMask = _mm_setzero_ps(); // Test for a divide by zero (Must be FP to detect -0.0) vZeroMask = _mm_cmpneq_ps(vZeroMask,vResult); // Failsafe on zero (Or epsilon) length planes // If the length is infinity, set the elements to zero vLengthSq = _mm_cmpneq_ps(vLengthSq,g_XMInfinity); // Divide to perform the normalization vResult = _mm_div_ps(V,vResult); // Any that are infinity, set to zero vResult = _mm_and_ps(vResult,vZeroMask); // Select qnan or result based on infinite length XMVECTOR vTemp1 = _mm_andnot_ps(vLengthSq,g_XMQNaN); XMVECTOR vTemp2 = _mm_and_ps(vResult,vLengthSq); vResult = _mm_or_ps(vTemp1,vTemp2); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4ClampLength( FXMVECTOR V, float LengthMin, float LengthMax){ XMVECTOR ClampMax = XMVectorReplicate(LengthMax); XMVECTOR ClampMin = XMVectorReplicate(LengthMin); return XMVector4ClampLengthV(V, ClampMin, ClampMax);}//------------------------------------------------------------------------------inline XMVECTOR XMVector4ClampLengthV( FXMVECTOR V, FXMVECTOR LengthMin, FXMVECTOR LengthMax){ assert((XMVectorGetY(LengthMin) == XMVectorGetX(LengthMin)) && (XMVectorGetZ(LengthMin) == XMVectorGetX(LengthMin)) && (XMVectorGetW(LengthMin) == XMVectorGetX(LengthMin))); assert((XMVectorGetY(LengthMax) == XMVectorGetX(LengthMax)) && (XMVectorGetZ(LengthMax) == XMVectorGetX(LengthMax)) && (XMVectorGetW(LengthMax) == XMVectorGetX(LengthMax))); assert(XMVector4GreaterOrEqual(LengthMin, XMVectorZero())); assert(XMVector4GreaterOrEqual(LengthMax, XMVectorZero())); assert(XMVector4GreaterOrEqual(LengthMax, LengthMin)); XMVECTOR LengthSq = XMVector4LengthSq(V); const XMVECTOR Zero = XMVectorZero(); XMVECTOR RcpLength = XMVectorReciprocalSqrt(LengthSq); XMVECTOR InfiniteLength = XMVectorEqualInt(LengthSq, g_XMInfinity.v); XMVECTOR ZeroLength = XMVectorEqual(LengthSq, Zero); XMVECTOR Normal = XMVectorMultiply(V, RcpLength); XMVECTOR Length = XMVectorMultiply(LengthSq, RcpLength); XMVECTOR Select = XMVectorEqualInt(InfiniteLength, ZeroLength); Length = XMVectorSelect(LengthSq, Length, Select); Normal = XMVectorSelect(LengthSq, Normal, Select); XMVECTOR ControlMax = XMVectorGreater(Length, LengthMax); XMVECTOR ControlMin = XMVectorLess(Length, LengthMin); XMVECTOR ClampLength = XMVectorSelect(Length, LengthMax, ControlMax); ClampLength = XMVectorSelect(ClampLength, LengthMin, ControlMin); XMVECTOR Result = XMVectorMultiply(Normal, ClampLength); // Preserve the original vector (with no precision loss) if the length falls within the given range XMVECTOR Control = XMVectorEqualInt(ControlMax, ControlMin); Result = XMVectorSelect(Result, V, Control); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Reflect( FXMVECTOR Incident, FXMVECTOR Normal){ // Result = Incident - (2 * dot(Incident, Normal)) * Normal XMVECTOR Result = XMVector4Dot(Incident, Normal); Result = XMVectorAdd(Result, Result); Result = XMVectorNegativeMultiplySubtract(Result, Normal, Incident); return Result;}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Refract( FXMVECTOR Incident, FXMVECTOR Normal, float RefractionIndex){ XMVECTOR Index = XMVectorReplicate(RefractionIndex); return XMVector4RefractV(Incident, Normal, Index);}//------------------------------------------------------------------------------inline XMVECTOR XMVector4RefractV( FXMVECTOR Incident, FXMVECTOR Normal, FXMVECTOR RefractionIndex){#if defined(_XM_NO_INTRINSICS_) XMVECTOR IDotN; XMVECTOR R; const XMVECTOR Zero = XMVectorZero(); // Result = RefractionIndex * Incident - Normal * (RefractionIndex * dot(Incident, Normal) + // sqrt(1 - RefractionIndex * RefractionIndex * (1 - dot(Incident, Normal) * dot(Incident, Normal)))) IDotN = XMVector4Dot(Incident, Normal); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) R = XMVectorNegativeMultiplySubtract(IDotN, IDotN, g_XMOne.v); R = XMVectorMultiply(R, RefractionIndex); R = XMVectorNegativeMultiplySubtract(R, RefractionIndex, g_XMOne.v); if (XMVector4LessOrEqual(R, Zero)) { // Total internal reflection return Zero; } else { XMVECTOR Result; // R = RefractionIndex * IDotN + sqrt(R) R = XMVectorSqrt(R); R = XMVectorMultiplyAdd(RefractionIndex, IDotN, R); // Result = RefractionIndex * Incident - Normal * R Result = XMVectorMultiply(RefractionIndex, Incident); Result = XMVectorNegativeMultiplySubtract(Normal, R, Result); return Result; }#elif defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR IDotN = XMVector4Dot(Incident,Normal); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) __n128 R = vmlsq_f32( g_XMOne, IDotN, IDotN); R = vmulq_f32(R, RefractionIndex); R = vmlsq_f32(g_XMOne, R, RefractionIndex ); __n128 vResult = vcleq_f32(R,g_XMZero); int8x8x2_t vTemp = vzip_u8(vget_low_u8(vResult), vget_high_u8(vResult)); vTemp = vzip_u16(vTemp.val[0], vTemp.val[1]); if ( vget_lane_u32(vTemp.val[1], 1) == 0xFFFFFFFFU ) { // Total internal reflection vResult = g_XMZero; } else { // Sqrt(R) __n128 S0 = vrsqrteq_f32(R); __n128 P0 = vmulq_f32( R, S0 ); __n128 R0 = vrsqrtsq_f32( P0, S0 ); __n128 S1 = vmulq_f32( S0, R0 ); __n128 P1 = vmulq_f32( R, S1 ); __n128 R1 = vrsqrtsq_f32( P1, S1 ); __n128 S2 = vmulq_f32( S1, R1 ); R = vmulq_f32( R, S2 ); // R = RefractionIndex * IDotN + sqrt(R) R = vmlaq_f32( R, RefractionIndex, IDotN ); // Result = RefractionIndex * Incident - Normal * R vResult = vmulq_f32(RefractionIndex, Incident); vResult = vmlsq_f32( vResult, R, Normal ); } return vResult;#elif defined(_XM_SSE_INTRINSICS_) XMVECTOR IDotN = XMVector4Dot(Incident,Normal); // R = 1.0f - RefractionIndex * RefractionIndex * (1.0f - IDotN * IDotN) XMVECTOR R = _mm_mul_ps(IDotN,IDotN); R = _mm_sub_ps(g_XMOne,R); R = _mm_mul_ps(R, RefractionIndex); R = _mm_mul_ps(R, RefractionIndex); R = _mm_sub_ps(g_XMOne,R); XMVECTOR vResult = _mm_cmple_ps(R,g_XMZero); if (_mm_movemask_ps(vResult)==0x0f) { // Total internal reflection vResult = g_XMZero; } else { // R = RefractionIndex * IDotN + sqrt(R) R = _mm_sqrt_ps(R); vResult = _mm_mul_ps(RefractionIndex, IDotN); R = _mm_add_ps(R,vResult); // Result = RefractionIndex * Incident - Normal * R vResult = _mm_mul_ps(RefractionIndex, Incident); R = _mm_mul_ps(R,Normal); vResult = _mm_sub_ps(vResult,R); } return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Orthogonal( FXMVECTOR V){#if defined(_XM_NO_INTRINSICS_) XMVECTOR Result; Result.vector4_f32[0] = V.vector4_f32[2]; Result.vector4_f32[1] = V.vector4_f32[3]; Result.vector4_f32[2] = -V.vector4_f32[0]; Result.vector4_f32[3] = -V.vector4_f32[1]; return Result;#elif defined(_XM_ARM_NEON_INTRINSICS_) static const XMVECTORF32 Negate = { 1.f, 1.f, -1.f, -1.f }; __n128 Result = vcombine_f32( vget_high_f32( V ), vget_low_f32( V ) ); return vmulq_f32( Result, Negate );#elif defined(_XM_SSE_INTRINSICS_) static const XMVECTORF32 FlipZW = {1.0f,1.0f,-1.0f,-1.0f}; XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,0,3,2)); vResult = _mm_mul_ps(vResult,FlipZW); return vResult;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4AngleBetweenNormalsEst( FXMVECTOR N1, FXMVECTOR N2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Result = XMVector4Dot(N1, N2); Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v); Result = XMVectorACosEst(Result); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4AngleBetweenNormals( FXMVECTOR N1, FXMVECTOR N2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR Result = XMVector4Dot(N1, N2); Result = XMVectorClamp(Result, g_XMNegativeOne.v, g_XMOne.v); Result = XMVectorACos(Result); return Result;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4AngleBetweenVectors( FXMVECTOR V1, FXMVECTOR V2){#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(_XM_ARM_NEON_INTRINSICS_) XMVECTOR L1 = XMVector4ReciprocalLength(V1); XMVECTOR L2 = XMVector4ReciprocalLength(V2); XMVECTOR Dot = XMVector4Dot(V1, V2); L1 = XMVectorMultiply(L1, L2); XMVECTOR CosAngle = XMVectorMultiply(Dot, L1); CosAngle = XMVectorClamp(CosAngle, g_XMNegativeOne.v, g_XMOne.v); return XMVectorACos(CosAngle);#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------inline XMVECTOR XMVector4Transform( FXMVECTOR V, CXMMATRIX M){#if defined(_XM_NO_INTRINSICS_) float fX = (M.m[0][0]*V.vector4_f32[0])+(M.m[1][0]*V.vector4_f32[1])+(M.m[2][0]*V.vector4_f32[2])+(M.m[3][0]*V.vector4_f32[3]); float fY = (M.m[0][1]*V.vector4_f32[0])+(M.m[1][1]*V.vector4_f32[1])+(M.m[2][1]*V.vector4_f32[2])+(M.m[3][1]*V.vector4_f32[3]); float fZ = (M.m[0][2]*V.vector4_f32[0])+(M.m[1][2]*V.vector4_f32[1])+(M.m[2][2]*V.vector4_f32[2])+(M.m[3][2]*V.vector4_f32[3]); float fW = (M.m[0][3]*V.vector4_f32[0])+(M.m[1][3]*V.vector4_f32[1])+(M.m[2][3]*V.vector4_f32[2])+(M.m[3][3]*V.vector4_f32[3]); XMVECTOR vResult = { fX, fY, fZ, fW }; return vResult;#elif defined(_XM_ARM_NEON_INTRINSICS_) __n64 VL = vget_low_f32( V ); XMVECTOR vTemp1 = vdupq_lane_f32( VL, 0 ); // X XMVECTOR vTemp2 = vdupq_lane_f32( VL, 1 ); // Y XMVECTOR vResult = vmulq_f32( vTemp1, M.r[0] ); vResult = vmlaq_f32( vResult, vTemp2, M.r[1] ); __n64 VH = vget_high_f32( V ); vTemp1 = vdupq_lane_f32( VH, 0 ); // Z vTemp2 = vdupq_lane_f32( VH, 1 ); // W vResult = vmlaq_f32( vResult, vTemp1, M.r[2] ); return vmlaq_f32( vResult, vTemp2, M.r[3] );#elif defined(_XM_SSE_INTRINSICS_) // Splat x,y,z and w XMVECTOR vTempX = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,0,0,0)); XMVECTOR vTempY = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1)); XMVECTOR vTempZ = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2)); XMVECTOR vTempW = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,3,3,3)); // Mul by the matrix vTempX = _mm_mul_ps(vTempX,M.r[0]); vTempY = _mm_mul_ps(vTempY,M.r[1]); vTempZ = _mm_mul_ps(vTempZ,M.r[2]); vTempW = _mm_mul_ps(vTempW,M.r[3]); // Add them all together vTempX = _mm_add_ps(vTempX,vTempY); vTempZ = _mm_add_ps(vTempZ,vTempW); vTempX = _mm_add_ps(vTempX,vTempZ); return vTempX;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}//------------------------------------------------------------------------------_Use_decl_annotations_inline XMFLOAT4* XMVector4TransformStream( XMFLOAT4* pOutputStream, size_t OutputStride, const XMFLOAT4* pInputStream, size_t InputStride, size_t VectorCount, CXMMATRIX M){ assert(pOutputStream != NULL); assert(pInputStream != NULL);#if defined(_XM_NO_INTRINSICS_) || defined(_XM_SSE_INTRINSICS_) || defined(XM_NO_MISALIGNED_VECTOR_ACCESS) || defined(_XM_ARM_NEON_INTRINSICS_) const uint8_t* pInputVector = (const uint8_t*)pInputStream; uint8_t* pOutputVector = (uint8_t*)pOutputStream; const XMVECTOR row0 = M.r[0]; const XMVECTOR row1 = M.r[1]; const XMVECTOR row2 = M.r[2]; const XMVECTOR row3 = M.r[3]; for (size_t i = 0; i < VectorCount; i++) { XMVECTOR V = XMLoadFloat4((const XMFLOAT4*)pInputVector); XMVECTOR W = XMVectorSplatW(V); XMVECTOR Z = XMVectorSplatZ(V); XMVECTOR Y = XMVectorSplatY(V); XMVECTOR X = XMVectorSplatX(V); XMVECTOR Result = XMVectorMultiply(W, row3); Result = XMVectorMultiplyAdd(Z, row2, Result); Result = XMVectorMultiplyAdd(Y, row1, Result); Result = XMVectorMultiplyAdd(X, row0, Result); XMStoreFloat4((XMFLOAT4*)pOutputVector, Result); pInputVector += InputStride; pOutputVector += OutputStride; } return pOutputStream;#else // _XM_VMX128_INTRINSICS_#endif // _XM_VMX128_INTRINSICS_}/**************************************************************************** * * XMVECTOR operators * ****************************************************************************///------------------------------------------------------------------------------inline XMVECTOR operator+ (FXMVECTOR V){ return V;}//------------------------------------------------------------------------------inline XMVECTOR operator- (FXMVECTOR V){ return XMVectorNegate(V);}//------------------------------------------------------------------------------inline XMVECTOR& operator+=( XMVECTOR& V1, FXMVECTOR V2){ V1 = XMVectorAdd(V1, V2); return V1;}//------------------------------------------------------------------------------inline XMVECTOR& operator-=( XMVECTOR& V1, FXMVECTOR V2){ V1 = XMVectorSubtract(V1, V2); return V1;}//------------------------------------------------------------------------------inline XMVECTOR& operator*=( XMVECTOR& V1, FXMVECTOR V2){ V1 = XMVectorMultiply(V1, V2); return V1;}//------------------------------------------------------------------------------inline XMVECTOR& operator/=( XMVECTOR& V1, FXMVECTOR V2){ V1 = XMVectorDivide(V1,V2); return V1;}//------------------------------------------------------------------------------inline XMVECTOR& operator*=( XMVECTOR& V, const float S){ V = XMVectorScale(V, S); return V;}//------------------------------------------------------------------------------inline XMVECTOR& operator/=( XMVECTOR& V, const float S){ assert( S != 0.0f ); V = XMVectorScale(V, 1.0f / S); return V;}//------------------------------------------------------------------------------inline XMVECTOR operator+( FXMVECTOR V1, FXMVECTOR V2){ return XMVectorAdd(V1, V2);}//------------------------------------------------------------------------------inline XMVECTOR operator-( FXMVECTOR V1, FXMVECTOR V2){ return XMVectorSubtract(V1, V2);}//------------------------------------------------------------------------------inline XMVECTOR operator*( FXMVECTOR V1, FXMVECTOR V2){ return XMVectorMultiply(V1, V2);}//------------------------------------------------------------------------------inline XMVECTOR operator/( FXMVECTOR V1, FXMVECTOR V2){ return XMVectorDivide(V1,V2);}//------------------------------------------------------------------------------inline XMVECTOR operator*( FXMVECTOR V, const float S){ return XMVectorScale(V, S);}//------------------------------------------------------------------------------inline XMVECTOR operator/( FXMVECTOR V, const float S){ assert( S != 0.0f ); return XMVectorScale(V, 1.0f / S);}//------------------------------------------------------------------------------inline XMVECTOR operator*( float S, FXMVECTOR V){ return XMVectorScale(V, S);}#if defined(_XM_NO_INTRINSICS_)#undef XMISNAN#undef XMISINF#endif