Scene.cs 257 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Diagnostics;
  30. using System.Drawing;
  31. using System.Drawing.Imaging;
  32. using System.IO;
  33. using System.Text;
  34. using System.Threading;
  35. using System.Timers;
  36. using System.Xml;
  37. using Nini.Config;
  38. using OpenMetaverse;
  39. using OpenMetaverse.Packets;
  40. using OpenMetaverse.Imaging;
  41. using OpenMetaverse.StructuredData;
  42. using OpenSim.Framework;
  43. using OpenSim.Framework.Monitoring;
  44. using OpenSim.Services.Interfaces;
  45. using OpenSim.Framework.Console;
  46. using OpenSim.Region.Framework.Interfaces;
  47. using OpenSim.Region.Framework.Scenes.Scripting;
  48. using OpenSim.Region.Framework.Scenes.Serialization;
  49. using OpenSim.Region.PhysicsModules.SharedBase;
  50. using Timer = System.Timers.Timer;
  51. using TPFlags = OpenSim.Framework.Constants.TeleportFlags;
  52. using GridRegion = OpenSim.Services.Interfaces.GridRegion;
  53. using PermissionMask = OpenSim.Framework.PermissionMask;
  54. namespace OpenSim.Region.Framework.Scenes
  55. {
  56. public delegate bool FilterAvatarList(ScenePresence avatar);
  57. public partial class Scene : SceneBase
  58. {
  59. private const long DEFAULT_MIN_TIME_FOR_PERSISTENCE = 60L;
  60. private const long DEFAULT_MAX_TIME_FOR_PERSISTENCE = 600L;
  61. public delegate void SynchronizeSceneHandler(Scene scene);
  62. #region Fields
  63. /// <summary>
  64. /// Show debug information about animations.
  65. /// </summary>
  66. public bool DebugAnimations { get; set; }
  67. /// <summary>
  68. /// Show debug information about teleports.
  69. /// </summary>
  70. public bool DebugTeleporting { get; set; }
  71. /// <summary>
  72. /// Show debug information about the scene loop.
  73. /// </summary>
  74. public bool DebugUpdates { get; set; }
  75. /// <summary>
  76. /// If true then the scene is saved to persistent storage periodically, every m_update_backup frames and
  77. /// if objects meet required conditions (m_dontPersistBefore and m_dontPersistAfter).
  78. /// </summary>
  79. /// <remarks>
  80. /// Even if false, the scene will still be saved on clean shutdown.
  81. /// FIXME: Currently, setting this to false will mean that objects are not periodically returned from parcels.
  82. /// This needs to be fixed.
  83. /// </remarks>
  84. public bool PeriodicBackup { get; set; }
  85. /// <summary>
  86. /// If false then the scene is never saved to persistence storage even if PeriodicBackup == true and even
  87. /// if the scene is being shut down for the final time.
  88. /// </summary>
  89. public bool UseBackup { get; set; }
  90. /// <summary>
  91. /// If false then physical objects are disabled, though collisions will continue as normal.
  92. /// </summary>
  93. public bool PhysicsEnabled
  94. {
  95. get
  96. {
  97. return m_physicsEnabled;
  98. }
  99. set
  100. {
  101. m_physicsEnabled = value;
  102. if (PhysicsScene != null)
  103. {
  104. IPhysicsParameters physScene = PhysicsScene as IPhysicsParameters;
  105. if (physScene != null)
  106. physScene.SetPhysicsParameter(
  107. "Active", m_physicsEnabled.ToString(), PhysParameterEntry.APPLY_TO_NONE);
  108. }
  109. }
  110. }
  111. private bool m_physicsEnabled;
  112. /// <summary>
  113. /// If false then scripts are not enabled on the smiulator
  114. /// </summary>
  115. public bool ScriptsEnabled
  116. {
  117. get { return m_scripts_enabled; }
  118. set
  119. {
  120. if (m_scripts_enabled != value)
  121. {
  122. if (!value)
  123. {
  124. m_log.Info("Stopping all Scripts in Scene");
  125. EntityBase[] entities = Entities.GetEntities();
  126. foreach (EntityBase ent in entities)
  127. {
  128. if (ent is SceneObjectGroup)
  129. ((SceneObjectGroup)ent).RemoveScriptInstances(false);
  130. }
  131. }
  132. else
  133. {
  134. m_log.Info("Starting all Scripts in Scene");
  135. EntityBase[] entities = Entities.GetEntities();
  136. foreach (EntityBase ent in entities)
  137. {
  138. if (ent is SceneObjectGroup)
  139. {
  140. SceneObjectGroup sog = (SceneObjectGroup)ent;
  141. sog.CreateScriptInstances(0, false, DefaultScriptEngine, 0);
  142. sog.ResumeScripts();
  143. }
  144. }
  145. }
  146. m_scripts_enabled = value;
  147. }
  148. }
  149. }
  150. private bool m_scripts_enabled;
  151. public SynchronizeSceneHandler SynchronizeScene;
  152. public bool ClampNegativeZ
  153. {
  154. get { return m_clampNegativeZ; }
  155. }
  156. private bool m_clampNegativeZ = false;
  157. /// <summary>
  158. /// Used to prevent simultaneous calls to code that adds and removes agents.
  159. /// </summary>
  160. private object m_removeClientLock = new object();
  161. /// <summary>
  162. /// Statistical information for this scene.
  163. /// </summary>
  164. public SimStatsReporter StatsReporter { get; private set; }
  165. /// <summary>
  166. /// Controls whether physics can be applied to prims. Even if false, prims still have entries in a
  167. /// PhysicsScene in order to perform collision detection
  168. /// </summary>
  169. public bool PhysicalPrims { get; private set; }
  170. /// <summary>
  171. /// Controls whether prims can be collided with.
  172. /// </summary>
  173. /// <remarks>
  174. /// If this is set to false then prims cannot be subject to physics either.
  175. /// </summary>
  176. public bool CollidablePrims { get; private set; }
  177. /// <summary>
  178. /// Minimum value of the size of a non-physical prim in each axis
  179. /// </summary>
  180. public float m_minNonphys = 0.001f;
  181. /// <summary>
  182. /// Maximum value of the size of a non-physical prim in each axis
  183. /// </summary>
  184. public float m_maxNonphys = 256;
  185. /// <summary>
  186. /// Minimum value of the size of a physical prim in each axis
  187. /// </summary>
  188. public float m_minPhys = 0.01f;
  189. /// <summary>
  190. /// Maximum value of the size of a physical prim in each axis
  191. /// </summary>
  192. public float m_maxPhys = 10;
  193. /// <summary>
  194. /// Max prims an object will hold
  195. /// </summary>
  196. public int m_linksetCapacity = 0;
  197. public bool m_clampPrimSize;
  198. public bool m_trustBinaries;
  199. public bool m_allowScriptCrossings = true;
  200. /// <summary>
  201. /// use legacy sittarget offsets to avoid contents breaks
  202. /// to compensate for SL bug
  203. /// </summary>
  204. public bool LegacySitOffsets = true;
  205. /// <summary>
  206. /// Can avatars cross from and to this region?
  207. /// </summary>
  208. public bool AllowAvatarCrossing { get; set; }
  209. /// Max prims an Physical object will hold
  210. /// </summary>
  211. ///
  212. public int m_linksetPhysCapacity = 0;
  213. /// <summary>
  214. /// When placed outside the region's border, do we transfer the objects or
  215. /// do we keep simulating them here?
  216. /// </summary>
  217. public bool DisableObjectTransfer { get; set; }
  218. public bool m_useFlySlow;
  219. public bool m_useTrashOnDelete = true;
  220. protected float m_defaultDrawDistance = 255f;
  221. protected float m_defaultCullingDrawDistance = 16f;
  222. public float DefaultDrawDistance
  223. {
  224. get { return ObjectsCullingByDistance?m_defaultCullingDrawDistance:m_defaultDrawDistance; }
  225. }
  226. protected float m_maxDrawDistance = 512.0f;
  227. // protected float m_maxDrawDistance = 256.0f;
  228. public float MaxDrawDistance
  229. {
  230. get { return m_maxDrawDistance; }
  231. }
  232. protected float m_maxRegionViewDistance = 255f;
  233. public float MaxRegionViewDistance
  234. {
  235. get { return m_maxRegionViewDistance; }
  236. }
  237. private List<string> m_AllowedViewers = new List<string>();
  238. private List<string> m_BannedViewers = new List<string>();
  239. // TODO: need to figure out how allow client agents but deny
  240. // root agents when ACL denies access to root agent
  241. public bool m_strictAccessControl = true;
  242. public bool m_seeIntoBannedRegion = false;
  243. public int MaxUndoCount = 5;
  244. public bool SeeIntoRegion { get; set; }
  245. // Using this for RegionReady module to prevent LoginsDisabled from changing under our feet;
  246. public bool LoginLock = false;
  247. public bool StartDisabled = false;
  248. public bool LoadingPrims;
  249. public IXfer XferManager;
  250. // the minimum time that must elapse before a changed object will be considered for persisted
  251. public long m_dontPersistBefore = DEFAULT_MIN_TIME_FOR_PERSISTENCE * 10000000L;
  252. // the maximum time that must elapse before a changed object will be considered for persisted
  253. public long m_persistAfter = DEFAULT_MAX_TIME_FOR_PERSISTENCE * 10000000L;
  254. protected int m_splitRegionID;
  255. protected Timer m_restartWaitTimer = new Timer();
  256. protected Timer m_timerWatchdog = new Timer();
  257. protected List<RegionInfo> m_regionRestartNotifyList = new List<RegionInfo>();
  258. protected List<RegionInfo> m_neighbours = new List<RegionInfo>();
  259. protected string m_simulatorVersion = "OpenSimulator Server";
  260. protected AgentCircuitManager m_authenticateHandler;
  261. protected SceneCommunicationService m_sceneGridService;
  262. protected ISnmpModule m_snmpService = null;
  263. protected ISimulationDataService m_SimulationDataService;
  264. protected IEstateDataService m_EstateDataService;
  265. protected IAssetService m_AssetService;
  266. protected IAuthorizationService m_AuthorizationService;
  267. protected IInventoryService m_InventoryService;
  268. protected IGridService m_GridService;
  269. protected ILibraryService m_LibraryService;
  270. protected ISimulationService m_simulationService;
  271. protected IAuthenticationService m_AuthenticationService;
  272. protected IPresenceService m_PresenceService;
  273. protected IUserAccountService m_UserAccountService;
  274. protected IAvatarService m_AvatarService;
  275. protected IGridUserService m_GridUserService;
  276. protected IAgentPreferencesService m_AgentPreferencesService;
  277. protected IXMLRPC m_xmlrpcModule;
  278. protected IWorldComm m_worldCommModule;
  279. protected IAvatarFactoryModule m_AvatarFactory;
  280. protected IConfigSource m_config;
  281. protected IRegionSerialiserModule m_serialiser;
  282. protected IDialogModule m_dialogModule;
  283. protected ICapabilitiesModule m_capsModule;
  284. protected IGroupsModule m_groupsModule;
  285. private Dictionary<string, string> m_extraSettings;
  286. /// <summary>
  287. /// Current scene frame number
  288. /// </summary>
  289. public uint Frame
  290. {
  291. get;
  292. protected set;
  293. }
  294. /// <summary>
  295. /// Frame time
  296. /// </remarks>
  297. public float FrameTime { get; private set; }
  298. public int FrameTimeWarnPercent { get; private set; }
  299. public int FrameTimeCritPercent { get; private set; }
  300. // Normalize the frame related stats to nominal 55fps for viewer and scripts option
  301. // see SimStatsReporter.cs
  302. public bool Normalized55FPS { get; private set; }
  303. private int m_update_physics = 1;
  304. private int m_update_entitymovement = 1;
  305. private int m_update_objects = 1;
  306. private int m_update_presences = 1; // Update scene presence movements
  307. private int m_update_events = 1;
  308. private int m_update_backup = 200;
  309. private int m_update_terrain = 1000;
  310. private int m_update_coarse_locations = 5;
  311. private int m_update_temp_cleaning = 180;
  312. private float agentMS;
  313. private float frameMS;
  314. private float physicsMS2;
  315. private float physicsMS;
  316. private float otherMS;
  317. private float tempOnRezMS;
  318. private float eventMS;
  319. private float backupMS;
  320. private float terrainMS;
  321. private float landMS;
  322. /// <summary>
  323. /// Tick at which the last frame was processed.
  324. /// </summary>
  325. private int m_lastFrameTick;
  326. /// <summary>
  327. /// Total script execution time (in Stopwatch Ticks) since the last frame
  328. /// </summary>
  329. private long m_scriptExecutionTime = 0;
  330. /// <summary>
  331. /// Signals whether temporary objects are currently being cleaned up. Needed because this is launched
  332. /// asynchronously from the update loop.
  333. /// </summary>
  334. private bool m_cleaningTemps = false;
  335. private bool m_sendingCoarseLocations = false; // same for async course locations sending
  336. /// <summary>
  337. /// Used to control main scene thread looping time when not updating via timer.
  338. /// </summary>
  339. private ManualResetEvent m_updateWaitEvent = new ManualResetEvent(false);
  340. // TODO: Possibly stop other classes being able to manipulate this directly.
  341. private SceneGraph m_sceneGraph;
  342. private readonly Timer m_restartTimer = new Timer(15000); // Wait before firing
  343. private volatile bool m_backingup;
  344. private Dictionary<UUID, ReturnInfo> m_returns = new Dictionary<UUID, ReturnInfo>();
  345. private Dictionary<UUID, int> m_groupsWithTargets = new Dictionary<UUID, int>();
  346. private string m_defaultScriptEngine;
  347. private int m_unixStartTime;
  348. public int UnixStartTime
  349. {
  350. get { return m_unixStartTime; }
  351. }
  352. /// <summary>
  353. /// Tick at which the last login occurred.
  354. /// </summary>
  355. private int m_LastLogin;
  356. private int m_lastIncoming;
  357. private int m_lastOutgoing;
  358. private int m_hbRestarts = 0;
  359. /// <summary>
  360. /// Thread that runs the scene loop.
  361. /// </summary>
  362. private Thread m_heartbeatThread;
  363. /// <summary>
  364. /// True if these scene is in the process of shutting down or is shutdown.
  365. /// </summary>
  366. public bool ShuttingDown
  367. {
  368. get { return m_shuttingDown; }
  369. }
  370. private volatile bool m_shuttingDown;
  371. /// <summary>
  372. /// Is the scene active?
  373. /// </summary>
  374. /// <remarks>
  375. /// If false, update loop is not being run, though after setting to false update may still
  376. /// be active for a period (and IsRunning will still be true). Updates can still be triggered manually if
  377. /// the scene is not active.
  378. /// </remarks>
  379. public bool Active
  380. {
  381. get { return m_active; }
  382. set
  383. {
  384. if (value)
  385. {
  386. if (!m_active)
  387. Start(false);
  388. }
  389. else
  390. {
  391. // This appears assymetric with Start() above but is not - setting m_active = false stops the loops
  392. // XXX: Possibly this should be in an explicit Stop() method for symmetry.
  393. m_active = false;
  394. }
  395. }
  396. }
  397. private volatile bool m_active;
  398. /// <summary>
  399. /// If true then updates are running. This may be true for a short period after a scene is de-activated.
  400. /// </summary>
  401. public bool IsRunning { get { return m_isRunning; } }
  402. private volatile bool m_isRunning;
  403. private bool m_firstHeartbeat = true;
  404. // private UpdatePrioritizationSchemes m_priorityScheme = UpdatePrioritizationSchemes.Time;
  405. // private bool m_reprioritizationEnabled = true;
  406. // private double m_reprioritizationInterval = 5000.0;
  407. // private double m_rootReprioritizationDistance = 10.0;
  408. // private double m_childReprioritizationDistance = 20.0;
  409. private Timer m_mapGenerationTimer = new Timer();
  410. private bool m_generateMaptiles;
  411. protected int m_lastHealth = -1;
  412. protected int m_lastUsers = -1;
  413. #endregion Fields
  414. #region Properties
  415. /* Used by the loadbalancer plugin on GForge */
  416. public int SplitRegionID
  417. {
  418. get { return m_splitRegionID; }
  419. set { m_splitRegionID = value; }
  420. }
  421. public new float TimeDilation
  422. {
  423. get { return m_sceneGraph.PhysicsScene.TimeDilation; }
  424. }
  425. public void setThreadCount(int inUseThreads)
  426. {
  427. // Just pass the thread count information on its way as the Scene
  428. // does not require the value for anything at this time
  429. StatsReporter.SetThreadCount(inUseThreads);
  430. }
  431. public SceneCommunicationService SceneGridService
  432. {
  433. get { return m_sceneGridService; }
  434. }
  435. public ISnmpModule SnmpService
  436. {
  437. get
  438. {
  439. if (m_snmpService == null)
  440. {
  441. m_snmpService = RequestModuleInterface<ISnmpModule>();
  442. }
  443. return m_snmpService;
  444. }
  445. }
  446. public ISimulationDataService SimulationDataService
  447. {
  448. get
  449. {
  450. if (m_SimulationDataService == null)
  451. {
  452. m_SimulationDataService = RequestModuleInterface<ISimulationDataService>();
  453. if (m_SimulationDataService == null)
  454. {
  455. throw new Exception("No ISimulationDataService available.");
  456. }
  457. }
  458. return m_SimulationDataService;
  459. }
  460. }
  461. public IEstateDataService EstateDataService
  462. {
  463. get
  464. {
  465. if (m_EstateDataService == null)
  466. {
  467. m_EstateDataService = RequestModuleInterface<IEstateDataService>();
  468. if (m_EstateDataService == null)
  469. {
  470. throw new Exception("No IEstateDataService available.");
  471. }
  472. }
  473. return m_EstateDataService;
  474. }
  475. }
  476. public IAssetService AssetService
  477. {
  478. get
  479. {
  480. if (m_AssetService == null)
  481. {
  482. m_AssetService = RequestModuleInterface<IAssetService>();
  483. if (m_AssetService == null)
  484. {
  485. throw new Exception("No IAssetService available.");
  486. }
  487. }
  488. return m_AssetService;
  489. }
  490. }
  491. public IAuthorizationService AuthorizationService
  492. {
  493. get
  494. {
  495. if (m_AuthorizationService == null)
  496. {
  497. m_AuthorizationService = RequestModuleInterface<IAuthorizationService>();
  498. //if (m_AuthorizationService == null)
  499. //{
  500. // // don't throw an exception if no authorization service is set for the time being
  501. // m_log.InfoFormat("[SCENE]: No Authorization service is configured");
  502. //}
  503. }
  504. return m_AuthorizationService;
  505. }
  506. }
  507. public IInventoryService InventoryService
  508. {
  509. get
  510. {
  511. if (m_InventoryService == null)
  512. {
  513. m_InventoryService = RequestModuleInterface<IInventoryService>();
  514. if (m_InventoryService == null)
  515. {
  516. throw new Exception("No IInventoryService available. This could happen if the config_include folder doesn't exist or if the OpenSim.ini [Architecture] section isn't set. Please also check that you have the correct version of your inventory service dll. Sometimes old versions of this dll will still exist. Do a clean checkout and re-create the opensim.ini from the opensim.ini.example.");
  517. }
  518. }
  519. return m_InventoryService;
  520. }
  521. }
  522. public IGridService GridService
  523. {
  524. get
  525. {
  526. if (m_GridService == null)
  527. {
  528. m_GridService = RequestModuleInterface<IGridService>();
  529. if (m_GridService == null)
  530. {
  531. throw new Exception("No IGridService available. This could happen if the config_include folder doesn't exist or if the OpenSim.ini [Architecture] section isn't set. Please also check that you have the correct version of your inventory service dll. Sometimes old versions of this dll will still exist. Do a clean checkout and re-create the opensim.ini from the opensim.ini.example.");
  532. }
  533. }
  534. return m_GridService;
  535. }
  536. }
  537. public ILibraryService LibraryService
  538. {
  539. get
  540. {
  541. if (m_LibraryService == null)
  542. m_LibraryService = RequestModuleInterface<ILibraryService>();
  543. return m_LibraryService;
  544. }
  545. }
  546. public ISimulationService SimulationService
  547. {
  548. get
  549. {
  550. if (m_simulationService == null)
  551. m_simulationService = RequestModuleInterface<ISimulationService>();
  552. return m_simulationService;
  553. }
  554. }
  555. public IAuthenticationService AuthenticationService
  556. {
  557. get
  558. {
  559. if (m_AuthenticationService == null)
  560. m_AuthenticationService = RequestModuleInterface<IAuthenticationService>();
  561. return m_AuthenticationService;
  562. }
  563. }
  564. public IPresenceService PresenceService
  565. {
  566. get
  567. {
  568. if (m_PresenceService == null)
  569. m_PresenceService = RequestModuleInterface<IPresenceService>();
  570. return m_PresenceService;
  571. }
  572. }
  573. public IUserAccountService UserAccountService
  574. {
  575. get
  576. {
  577. if (m_UserAccountService == null)
  578. m_UserAccountService = RequestModuleInterface<IUserAccountService>();
  579. return m_UserAccountService;
  580. }
  581. }
  582. public IAvatarService AvatarService
  583. {
  584. get
  585. {
  586. if (m_AvatarService == null)
  587. m_AvatarService = RequestModuleInterface<IAvatarService>();
  588. return m_AvatarService;
  589. }
  590. }
  591. public IGridUserService GridUserService
  592. {
  593. get
  594. {
  595. if (m_GridUserService == null)
  596. m_GridUserService = RequestModuleInterface<IGridUserService>();
  597. return m_GridUserService;
  598. }
  599. }
  600. public IAgentPreferencesService AgentPreferencesService
  601. {
  602. get
  603. {
  604. if (m_AgentPreferencesService == null)
  605. m_AgentPreferencesService = RequestModuleInterface<IAgentPreferencesService>();
  606. return m_AgentPreferencesService;
  607. }
  608. }
  609. public IAttachmentsModule AttachmentsModule { get; set; }
  610. public IEntityTransferModule EntityTransferModule { get; private set; }
  611. public IAgentAssetTransactions AgentTransactionsModule { get; private set; }
  612. public IUserManagement UserManagementModule { get; private set; }
  613. public IAvatarFactoryModule AvatarFactory
  614. {
  615. get { return m_AvatarFactory; }
  616. }
  617. public ICapabilitiesModule CapsModule
  618. {
  619. get { return m_capsModule; }
  620. }
  621. public int MonitorFrameTime { get { return (int)frameMS; } }
  622. public int MonitorPhysicsUpdateTime { get { return (int)physicsMS; } }
  623. public int MonitorPhysicsSyncTime { get { return (int)physicsMS2; } }
  624. public int MonitorOtherTime { get { return (int)otherMS; } }
  625. public int MonitorTempOnRezTime { get { return (int)tempOnRezMS; } }
  626. public int MonitorEventTime { get { return (int)eventMS; } } // This may need to be divided into each event?
  627. public int MonitorBackupTime { get { return (int)backupMS; } }
  628. public int MonitorTerrainTime { get { return (int)terrainMS; } }
  629. public int MonitorLandTime { get { return (int)landMS; } }
  630. public int MonitorLastFrameTick { get { return m_lastFrameTick; } }
  631. public UpdatePrioritizationSchemes UpdatePrioritizationScheme { get; set; }
  632. public bool IsReprioritizationEnabled { get; set; }
  633. public float ReprioritizationInterval { get; set; }
  634. public float ReprioritizationDistance { get; set; }
  635. private float m_minReprioritizationDistance = 32f;
  636. public bool ObjectsCullingByDistance = false;
  637. private ExpiringCache<UUID, UUID> TeleportTargetsCoolDown = new ExpiringCache<UUID, UUID>();
  638. public AgentCircuitManager AuthenticateHandler
  639. {
  640. get { return m_authenticateHandler; }
  641. }
  642. // an instance to the physics plugin's Scene object.
  643. public PhysicsScene PhysicsScene
  644. {
  645. get { return m_sceneGraph.PhysicsScene; }
  646. set
  647. {
  648. // If we're not doing the initial set
  649. // Then we've got to remove the previous
  650. // event handler
  651. if (PhysicsScene != null && PhysicsScene.SupportsNINJAJoints)
  652. {
  653. PhysicsScene.OnJointMoved -= jointMoved;
  654. PhysicsScene.OnJointDeactivated -= jointDeactivated;
  655. PhysicsScene.OnJointErrorMessage -= jointErrorMessage;
  656. }
  657. m_sceneGraph.PhysicsScene = value;
  658. if (PhysicsScene != null && m_sceneGraph.PhysicsScene.SupportsNINJAJoints)
  659. {
  660. // register event handlers to respond to joint movement/deactivation
  661. PhysicsScene.OnJointMoved += jointMoved;
  662. PhysicsScene.OnJointDeactivated += jointDeactivated;
  663. PhysicsScene.OnJointErrorMessage += jointErrorMessage;
  664. }
  665. }
  666. }
  667. public string DefaultScriptEngine
  668. {
  669. get { return m_defaultScriptEngine; }
  670. }
  671. public EntityManager Entities
  672. {
  673. get { return m_sceneGraph.Entities; }
  674. }
  675. // used in sequence see: SpawnPoint()
  676. private int m_SpawnPoint;
  677. // can be closest/random/sequence
  678. public string SpawnPointRouting
  679. {
  680. get;
  681. private set;
  682. }
  683. // allow landmarks to pass
  684. public bool TelehubAllowLandmarks
  685. {
  686. get;
  687. private set;
  688. }
  689. #endregion Properties
  690. #region Constructors
  691. public Scene(RegionInfo regInfo, AgentCircuitManager authen,
  692. ISimulationDataService simDataService, IEstateDataService estateDataService,
  693. IConfigSource config, string simulatorVersion)
  694. : this(regInfo)
  695. {
  696. m_config = config;
  697. FrameTime = 0.0908f;
  698. FrameTimeWarnPercent = 60;
  699. FrameTimeCritPercent = 40;
  700. Normalized55FPS = true;
  701. SeeIntoRegion = true;
  702. Random random = new Random();
  703. m_lastAllocatedLocalId = (uint)(random.NextDouble() * (double)(uint.MaxValue / 2)) + (uint)(uint.MaxValue / 4);
  704. m_authenticateHandler = authen;
  705. m_sceneGridService = new SceneCommunicationService();
  706. m_SimulationDataService = simDataService;
  707. m_EstateDataService = estateDataService;
  708. m_lastIncoming = 0;
  709. m_lastOutgoing = 0;
  710. m_asyncSceneObjectDeleter = new AsyncSceneObjectGroupDeleter(this);
  711. m_asyncSceneObjectDeleter.Enabled = true;
  712. m_asyncInventorySender = new AsyncInventorySender(this);
  713. #region Region Settings
  714. // Load region settings
  715. // LoadRegionSettings creates new region settings in persistence if they don't already exist for this region.
  716. // However, in this case, the default textures are not set in memory properly, so we need to do it here and
  717. // resave.
  718. // FIXME: It shouldn't be up to the database plugins to create this data - we should do it when a new
  719. // region is set up and avoid these gyrations.
  720. RegionSettings rs = simDataService.LoadRegionSettings(RegionInfo.RegionID);
  721. m_extraSettings = simDataService.GetExtra(RegionInfo.RegionID);
  722. bool updatedTerrainTextures = false;
  723. if (rs.TerrainTexture1 == UUID.Zero)
  724. {
  725. rs.TerrainTexture1 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_1;
  726. updatedTerrainTextures = true;
  727. }
  728. if (rs.TerrainTexture2 == UUID.Zero)
  729. {
  730. rs.TerrainTexture2 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_2;
  731. updatedTerrainTextures = true;
  732. }
  733. if (rs.TerrainTexture3 == UUID.Zero)
  734. {
  735. rs.TerrainTexture3 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_3;
  736. updatedTerrainTextures = true;
  737. }
  738. if (rs.TerrainTexture4 == UUID.Zero)
  739. {
  740. rs.TerrainTexture4 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_4;
  741. updatedTerrainTextures = true;
  742. }
  743. if (updatedTerrainTextures)
  744. rs.Save();
  745. RegionInfo.RegionSettings = rs;
  746. if (estateDataService != null)
  747. RegionInfo.EstateSettings = estateDataService.LoadEstateSettings(RegionInfo.RegionID, false);
  748. #endregion Region Settings
  749. //Bind Storage Manager functions to some land manager functions for this scene
  750. EventManager.OnLandObjectAdded +=
  751. new EventManager.LandObjectAdded(simDataService.StoreLandObject);
  752. EventManager.OnLandObjectRemoved +=
  753. new EventManager.LandObjectRemoved(simDataService.RemoveLandObject);
  754. RegisterDefaultSceneEvents();
  755. // XXX: Don't set the public property since we don't want to activate here. This needs to be handled
  756. // better in the future.
  757. m_scripts_enabled = !RegionInfo.RegionSettings.DisableScripts;
  758. PhysicsEnabled = !RegionInfo.RegionSettings.DisablePhysics;
  759. m_simulatorVersion = simulatorVersion + " (" + Util.GetRuntimeInformation() + ")";
  760. #region Region Config
  761. // Region config overrides global config
  762. //
  763. if (m_config.Configs["Startup"] != null)
  764. {
  765. IConfig startupConfig = m_config.Configs["Startup"];
  766. StartDisabled = startupConfig.GetBoolean("StartDisabled", false);
  767. m_defaultDrawDistance = startupConfig.GetFloat("DefaultDrawDistance", m_defaultDrawDistance);
  768. m_maxDrawDistance = startupConfig.GetFloat("MaxDrawDistance", m_maxDrawDistance);
  769. m_maxRegionViewDistance = startupConfig.GetFloat("MaxRegionsViewDistance", m_maxRegionViewDistance);
  770. // old versions compatibility
  771. LegacySitOffsets = startupConfig.GetBoolean("LegacySitOffsets", LegacySitOffsets);
  772. if (m_defaultDrawDistance > m_maxDrawDistance)
  773. m_defaultDrawDistance = m_maxDrawDistance;
  774. if (m_maxRegionViewDistance > m_maxDrawDistance)
  775. m_maxRegionViewDistance = m_maxDrawDistance;
  776. UseBackup = startupConfig.GetBoolean("UseSceneBackup", UseBackup);
  777. if (!UseBackup)
  778. m_log.InfoFormat("[SCENE]: Backup has been disabled for {0}", RegionInfo.RegionName);
  779. //Animation states
  780. m_useFlySlow = startupConfig.GetBoolean("enableflyslow", false);
  781. SeeIntoRegion = startupConfig.GetBoolean("see_into_region", SeeIntoRegion);
  782. MaxUndoCount = startupConfig.GetInt("MaxPrimUndos", 20);
  783. PhysicalPrims = startupConfig.GetBoolean("physical_prim", true);
  784. CollidablePrims = startupConfig.GetBoolean("collidable_prim", true);
  785. m_minNonphys = startupConfig.GetFloat("NonPhysicalPrimMin", m_minNonphys);
  786. if (RegionInfo.NonphysPrimMin > 0)
  787. {
  788. m_minNonphys = RegionInfo.NonphysPrimMin;
  789. }
  790. // don't allow nonsense values
  791. if(m_minNonphys < 0.001f)
  792. m_minNonphys = 0.001f;
  793. m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
  794. if (RegionInfo.NonphysPrimMax > 0)
  795. {
  796. m_maxNonphys = RegionInfo.NonphysPrimMax;
  797. }
  798. if (m_maxNonphys > 65536)
  799. m_maxNonphys = 65536;
  800. m_minPhys = startupConfig.GetFloat("PhysicalPrimMin", m_minPhys);
  801. if (RegionInfo.PhysPrimMin > 0)
  802. {
  803. m_minPhys = RegionInfo.PhysPrimMin;
  804. }
  805. if(m_minPhys < 0.01f)
  806. m_minPhys = 0.01f;
  807. m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);
  808. if (RegionInfo.PhysPrimMax > 0)
  809. {
  810. m_maxPhys = RegionInfo.PhysPrimMax;
  811. }
  812. if (m_maxPhys > 2048)
  813. m_maxPhys = 2048;
  814. m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
  815. if (RegionInfo.LinksetCapacity > 0)
  816. {
  817. m_linksetCapacity = RegionInfo.LinksetCapacity;
  818. }
  819. m_linksetPhysCapacity = startupConfig.GetInt("LinksetPhysPrims", m_linksetPhysCapacity);
  820. SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
  821. TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
  822. // Here, if clamping is requested in either global or
  823. // local config, it will be used
  824. //
  825. m_clampPrimSize = startupConfig.GetBoolean("ClampPrimSize", m_clampPrimSize);
  826. if (RegionInfo.ClampPrimSize)
  827. {
  828. m_clampPrimSize = true;
  829. }
  830. m_clampNegativeZ = startupConfig.GetBoolean("ClampNegativeZ", m_clampNegativeZ);
  831. m_useTrashOnDelete = startupConfig.GetBoolean("UseTrashOnDelete",m_useTrashOnDelete);
  832. m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", m_trustBinaries);
  833. m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", m_allowScriptCrossings);
  834. m_dontPersistBefore =
  835. startupConfig.GetLong("MinimumTimeBeforePersistenceConsidered", DEFAULT_MIN_TIME_FOR_PERSISTENCE);
  836. m_dontPersistBefore *= 10000000;
  837. m_persistAfter =
  838. startupConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE);
  839. m_persistAfter *= 10000000;
  840. m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
  841. m_log.InfoFormat("[SCENE]: Default script engine {0}", m_defaultScriptEngine);
  842. m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl);
  843. m_seeIntoBannedRegion = startupConfig.GetBoolean("SeeIntoBannedRegion", m_seeIntoBannedRegion);
  844. string[] possibleMapConfigSections = new string[] { "Map", "Startup" };
  845. m_generateMaptiles
  846. = Util.GetConfigVarFromSections<bool>(config, "GenerateMaptiles", possibleMapConfigSections, true);
  847. if (m_generateMaptiles)
  848. {
  849. int maptileRefresh = Util.GetConfigVarFromSections<int>(config, "MaptileRefresh", possibleMapConfigSections, 0);
  850. m_log.InfoFormat("[SCENE]: Region {0}, WORLD MAP refresh time set to {1} seconds", RegionInfo.RegionName, maptileRefresh);
  851. if (maptileRefresh != 0)
  852. {
  853. m_mapGenerationTimer.Interval = maptileRefresh * 1000;
  854. m_mapGenerationTimer.Elapsed += RegenerateMaptileAndReregister;
  855. m_mapGenerationTimer.AutoReset = true;
  856. m_mapGenerationTimer.Start();
  857. }
  858. }
  859. else
  860. {
  861. string tile
  862. = Util.GetConfigVarFromSections<string>(
  863. config, "MaptileStaticUUID", possibleMapConfigSections, UUID.Zero.ToString());
  864. UUID tileID;
  865. if (tile != UUID.Zero.ToString() && UUID.TryParse(tile, out tileID))
  866. {
  867. RegionInfo.RegionSettings.TerrainImageID = tileID;
  868. }
  869. else
  870. {
  871. RegionInfo.RegionSettings.TerrainImageID = RegionInfo.MaptileStaticUUID;
  872. m_log.InfoFormat("[SCENE]: Region {0}, maptile set to {1}", RegionInfo.RegionName, RegionInfo.MaptileStaticUUID.ToString());
  873. }
  874. }
  875. string[] possibleAccessControlConfigSections = new string[] { "Startup", "AccessControl"};
  876. string grant
  877. = Util.GetConfigVarFromSections<string>(
  878. config, "AllowedClients", possibleAccessControlConfigSections, string.Empty);
  879. if (grant.Length > 0)
  880. {
  881. foreach (string viewer in grant.Split(','))
  882. {
  883. m_AllowedViewers.Add(viewer.Trim().ToLower());
  884. }
  885. }
  886. grant
  887. = Util.GetConfigVarFromSections<string>(
  888. config, "DeniedClients", possibleAccessControlConfigSections, String.Empty);
  889. // Deal with the mess of someone having used a different word at some point
  890. if (grant == String.Empty)
  891. grant = Util.GetConfigVarFromSections<string>(
  892. config, "BannedClients", possibleAccessControlConfigSections, String.Empty);
  893. if (grant.Length > 0)
  894. {
  895. foreach (string viewer in grant.Split(','))
  896. {
  897. m_BannedViewers.Add(viewer.Trim().ToLower());
  898. }
  899. }
  900. FrameTime = startupConfig.GetFloat( "FrameTime", FrameTime);
  901. FrameTimeWarnPercent = startupConfig.GetInt( "FrameTimeWarnPercent", FrameTimeWarnPercent);
  902. FrameTimeCritPercent = startupConfig.GetInt( "FrameTimeCritPercent", FrameTimeCritPercent);
  903. Normalized55FPS = startupConfig.GetBoolean( "Normalized55FPS", Normalized55FPS);
  904. m_update_backup = startupConfig.GetInt("UpdateStorageEveryNFrames", m_update_backup);
  905. m_update_coarse_locations = startupConfig.GetInt("UpdateCoarseLocationsEveryNFrames", m_update_coarse_locations);
  906. m_update_entitymovement = startupConfig.GetInt("UpdateEntityMovementEveryNFrames", m_update_entitymovement);
  907. m_update_events = startupConfig.GetInt("UpdateEventsEveryNFrames", m_update_events);
  908. m_update_objects = startupConfig.GetInt("UpdateObjectsEveryNFrames", m_update_objects);
  909. m_update_physics = startupConfig.GetInt("UpdatePhysicsEveryNFrames", m_update_physics);
  910. m_update_presences = startupConfig.GetInt("UpdateAgentsEveryNFrames", m_update_presences);
  911. m_update_terrain = startupConfig.GetInt("UpdateTerrainEveryNFrames", m_update_terrain);
  912. m_update_temp_cleaning = startupConfig.GetInt("UpdateTempCleaningEveryNSeconds", m_update_temp_cleaning);
  913. }
  914. #endregion Region Config
  915. IConfig entityTransferConfig = m_config.Configs["EntityTransfer"];
  916. if (entityTransferConfig != null)
  917. {
  918. AllowAvatarCrossing = entityTransferConfig.GetBoolean("AllowAvatarCrossing", AllowAvatarCrossing);
  919. DisableObjectTransfer = entityTransferConfig.GetBoolean("DisableObjectTransfer", false);
  920. }
  921. #region Interest Management
  922. IConfig interestConfig = m_config.Configs["InterestManagement"];
  923. if (interestConfig != null)
  924. {
  925. string update_prioritization_scheme = interestConfig.GetString("UpdatePrioritizationScheme", "Time").Trim().ToLower();
  926. try
  927. {
  928. UpdatePrioritizationScheme = (UpdatePrioritizationSchemes)Enum.Parse(typeof(UpdatePrioritizationSchemes), update_prioritization_scheme, true);
  929. }
  930. catch (Exception)
  931. {
  932. m_log.Warn("[PRIORITIZER]: UpdatePrioritizationScheme was not recognized, setting to default BestAvatarResponsiveness");
  933. UpdatePrioritizationScheme = UpdatePrioritizationSchemes.BestAvatarResponsiveness;
  934. }
  935. IsReprioritizationEnabled
  936. = interestConfig.GetBoolean("ReprioritizationEnabled", IsReprioritizationEnabled);
  937. ReprioritizationInterval
  938. = interestConfig.GetFloat("ReprioritizationInterval", ReprioritizationInterval);
  939. ReprioritizationDistance
  940. = interestConfig.GetFloat("RootReprioritizationDistance", ReprioritizationDistance);
  941. if(ReprioritizationDistance < m_minReprioritizationDistance)
  942. ReprioritizationDistance = m_minReprioritizationDistance;
  943. ObjectsCullingByDistance
  944. = interestConfig.GetBoolean("ObjectsCullingByDistance", ObjectsCullingByDistance);
  945. }
  946. m_log.DebugFormat("[SCENE]: Using the {0} prioritization scheme", UpdatePrioritizationScheme);
  947. #endregion Interest Management
  948. StatsReporter = new SimStatsReporter(this);
  949. StatsReporter.OnSendStatsResult += SendSimStatsPackets;
  950. StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;
  951. IConfig restartConfig = config.Configs["RestartModule"];
  952. if (restartConfig != null)
  953. {
  954. string markerPath = restartConfig.GetString("MarkerPath", String.Empty);
  955. if (markerPath != String.Empty)
  956. {
  957. string path = Path.Combine(markerPath, RegionInfo.RegionID.ToString() + ".started");
  958. try
  959. {
  960. string pidstring = System.Diagnostics.Process.GetCurrentProcess().Id.ToString();
  961. FileStream fs = File.Create(path);
  962. System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
  963. Byte[] buf = enc.GetBytes(pidstring);
  964. fs.Write(buf, 0, buf.Length);
  965. fs.Close();
  966. }
  967. catch (Exception)
  968. {
  969. }
  970. }
  971. }
  972. StartTimerWatchdog();
  973. }
  974. public Scene(RegionInfo regInfo)
  975. : base(regInfo)
  976. {
  977. m_sceneGraph = new SceneGraph(this);
  978. // If the scene graph has an Unrecoverable error, restart this sim.
  979. // Currently the only thing that causes it to happen is two kinds of specific
  980. // Physics based crashes.
  981. //
  982. // Out of memory
  983. // Operating system has killed the plugin
  984. m_sceneGraph.UnRecoverableError
  985. += () =>
  986. {
  987. m_log.ErrorFormat("[SCENE]: Restarting region {0} due to unrecoverable physics crash", Name);
  988. RestartNow();
  989. };
  990. PhysicalPrims = true;
  991. CollidablePrims = true;
  992. PhysicsEnabled = true;
  993. AllowAvatarCrossing = true;
  994. PeriodicBackup = true;
  995. UseBackup = true;
  996. IsReprioritizationEnabled = true;
  997. UpdatePrioritizationScheme = UpdatePrioritizationSchemes.BestAvatarResponsiveness;
  998. ReprioritizationInterval = 5000;
  999. ReprioritizationDistance = m_minReprioritizationDistance;
  1000. m_eventManager = new EventManager();
  1001. m_permissions = new ScenePermissions(this);
  1002. }
  1003. #endregion
  1004. #region Startup / Close Methods
  1005. /// <value>
  1006. /// The scene graph for this scene
  1007. /// </value>
  1008. /// TODO: Possibly stop other classes being able to manipulate this directly.
  1009. public SceneGraph SceneGraph
  1010. {
  1011. get { return m_sceneGraph; }
  1012. }
  1013. /// <summary>
  1014. /// Called by the module loader when all modules are loaded, after each module's
  1015. /// RegionLoaded hook is called. This is the earliest time where RequestModuleInterface
  1016. /// may be used.
  1017. /// </summary>
  1018. public void AllModulesLoaded()
  1019. {
  1020. IDialogModule dm = RequestModuleInterface<IDialogModule>();
  1021. if (dm != null)
  1022. m_eventManager.OnPermissionError += dm.SendAlertToUser;
  1023. ISimulatorFeaturesModule fm = RequestModuleInterface<ISimulatorFeaturesModule>();
  1024. if (fm != null)
  1025. {
  1026. OSD openSimExtras;
  1027. OSDMap openSimExtrasMap;
  1028. if (!fm.TryGetFeature("OpenSimExtras", out openSimExtras))
  1029. openSimExtras = new OSDMap();
  1030. float statisticsFPSfactor = 1.0f;
  1031. if(Normalized55FPS)
  1032. statisticsFPSfactor = 55.0f * FrameTime;
  1033. openSimExtrasMap = (OSDMap)openSimExtras;
  1034. openSimExtrasMap["SimulatorFPS"] = OSD.FromReal(1.0f / FrameTime);
  1035. openSimExtrasMap["SimulatorFPSFactor"] = OSD.FromReal(statisticsFPSfactor);
  1036. openSimExtrasMap["SimulatorFPSWarnPercent"] = OSD.FromInteger(FrameTimeWarnPercent);
  1037. openSimExtrasMap["SimulatorFPSCritPercent"] = OSD.FromInteger(FrameTimeCritPercent);
  1038. fm.AddFeature("OpenSimExtras", openSimExtrasMap);
  1039. }
  1040. }
  1041. protected virtual void RegisterDefaultSceneEvents()
  1042. {
  1043. // m_eventManager.OnSignificantClientMovement += HandleOnSignificantClientMovement;
  1044. }
  1045. public override string GetSimulatorVersion()
  1046. {
  1047. return m_simulatorVersion;
  1048. }
  1049. /// <summary>
  1050. /// Process the fact that a neighbouring region has come up.
  1051. /// </summary>
  1052. /// <remarks>
  1053. /// We only add it to the neighbor list if it's within 1 region from here.
  1054. /// Agents may have draw distance values that cross two regions though, so
  1055. /// we add it to the notify list regardless of distance. We'll check
  1056. /// the agent's draw distance before notifying them though.
  1057. /// </remarks>
  1058. /// <param name="otherRegion">RegionInfo handle for the new region.</param>
  1059. /// <returns>True after all operations complete, throws exceptions otherwise.</returns>
  1060. public override void OtherRegionUp(GridRegion otherRegion)
  1061. {
  1062. if (RegionInfo.RegionHandle != otherRegion.RegionHandle)
  1063. {
  1064. if (isNeighborRegion(otherRegion))
  1065. {
  1066. // Let the grid service module know, so this can be cached
  1067. m_eventManager.TriggerOnRegionUp(otherRegion);
  1068. try
  1069. {
  1070. ForEachRootScenePresence(delegate(ScenePresence agent)
  1071. {
  1072. //agent.ControllingClient.new
  1073. //this.CommsManager.InterRegion.InformRegionOfChildAgent(otherRegion.RegionHandle, agent.ControllingClient.RequestClientInfo());
  1074. List<ulong> old = new List<ulong>();
  1075. old.Add(otherRegion.RegionHandle);
  1076. agent.DropOldNeighbours(old);
  1077. if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
  1078. EntityTransferModule.EnableChildAgent(agent, otherRegion);
  1079. });
  1080. }
  1081. catch (NullReferenceException)
  1082. {
  1083. // This means that we're not booted up completely yet.
  1084. // This shouldn't happen too often anymore.
  1085. m_log.Error("[SCENE]: Couldn't inform client of regionup because we got a null reference exception");
  1086. }
  1087. }
  1088. else
  1089. {
  1090. m_log.InfoFormat(
  1091. "[SCENE]: Got notice about far away Region: {0} at ({1}, {2})",
  1092. otherRegion.RegionName, otherRegion.RegionLocX, otherRegion.RegionLocY);
  1093. }
  1094. }
  1095. }
  1096. public bool isNeighborRegion(GridRegion otherRegion)
  1097. {
  1098. int tmp = otherRegion.RegionLocX - (int)RegionInfo.WorldLocX; ;
  1099. if (tmp < -otherRegion.RegionSizeX && tmp > RegionInfo.RegionSizeX)
  1100. return false;
  1101. tmp = otherRegion.RegionLocY - (int)RegionInfo.WorldLocY;
  1102. if (tmp < -otherRegion.RegionSizeY && tmp > RegionInfo.RegionSizeY)
  1103. return false;
  1104. return true;
  1105. }
  1106. public void AddNeighborRegion(RegionInfo region)
  1107. {
  1108. lock (m_neighbours)
  1109. {
  1110. if (!CheckNeighborRegion(region))
  1111. {
  1112. m_neighbours.Add(region);
  1113. }
  1114. }
  1115. }
  1116. public bool CheckNeighborRegion(RegionInfo region)
  1117. {
  1118. bool found = false;
  1119. lock (m_neighbours)
  1120. {
  1121. foreach (RegionInfo reg in m_neighbours)
  1122. {
  1123. if (reg.RegionHandle == region.RegionHandle)
  1124. {
  1125. found = true;
  1126. break;
  1127. }
  1128. }
  1129. }
  1130. return found;
  1131. }
  1132. // Alias IncomingHelloNeighbour OtherRegionUp, for now
  1133. public GridRegion IncomingHelloNeighbour(RegionInfo neighbour)
  1134. {
  1135. OtherRegionUp(new GridRegion(neighbour));
  1136. return new GridRegion(RegionInfo);
  1137. }
  1138. // This causes the region to restart immediatley.
  1139. public void RestartNow()
  1140. {
  1141. IConfig startupConfig = m_config.Configs["Startup"];
  1142. if (startupConfig != null)
  1143. {
  1144. if (startupConfig.GetBoolean("InworldRestartShutsDown", false))
  1145. {
  1146. MainConsole.Instance.RunCommand("shutdown");
  1147. return;
  1148. }
  1149. }
  1150. m_log.InfoFormat("[REGION]: Restarting region {0}", Name);
  1151. Close();
  1152. base.Restart();
  1153. }
  1154. // This is a helper function that notifies root agents in this region that a new sim near them has come up
  1155. // This is in the form of a timer because when an instance of OpenSim.exe is started,
  1156. // Even though the sims initialize, they don't listen until 'all of the sims are initialized'
  1157. // If we tell an agent about a sim that's not listening yet, the agent will not be able to connect to it.
  1158. // subsequently the agent will never see the region come back online.
  1159. public void RestartNotifyWaitElapsed(object sender, ElapsedEventArgs e)
  1160. {
  1161. m_restartWaitTimer.Stop();
  1162. lock (m_regionRestartNotifyList)
  1163. {
  1164. foreach (RegionInfo region in m_regionRestartNotifyList)
  1165. {
  1166. GridRegion r = new GridRegion(region);
  1167. try
  1168. {
  1169. ForEachRootScenePresence(delegate(ScenePresence agent)
  1170. {
  1171. if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
  1172. EntityTransferModule.EnableChildAgent(agent, r);
  1173. });
  1174. }
  1175. catch (NullReferenceException)
  1176. {
  1177. // This means that we're not booted up completely yet.
  1178. // This shouldn't happen too often anymore.
  1179. }
  1180. }
  1181. // Reset list to nothing.
  1182. m_regionRestartNotifyList.Clear();
  1183. }
  1184. }
  1185. public int GetInaccurateNeighborCount()
  1186. {
  1187. return m_neighbours.Count;
  1188. }
  1189. // This is the method that shuts down the scene.
  1190. public override void Close()
  1191. {
  1192. if (m_shuttingDown)
  1193. {
  1194. m_log.WarnFormat("[SCENE]: Ignoring close request because already closing {0}", Name);
  1195. return;
  1196. }
  1197. IEtcdModule etcd = RequestModuleInterface<IEtcdModule>();
  1198. if (etcd != null)
  1199. {
  1200. etcd.Delete("Health");
  1201. etcd.Delete("HealthFlags");
  1202. etcd.Delete("RootAgents");
  1203. }
  1204. m_log.InfoFormat("[SCENE]: Closing down the single simulator: {0}", RegionInfo.RegionName);
  1205. StatsReporter.Close();
  1206. m_restartTimer.Stop();
  1207. m_restartTimer.Close();
  1208. if (!GridService.DeregisterRegion(RegionInfo.RegionID))
  1209. m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
  1210. // Kick all ROOT agents with the message, 'The simulator is going down'
  1211. ForEachScenePresence(delegate(ScenePresence avatar)
  1212. {
  1213. avatar.RemoveNeighbourRegion(RegionInfo.RegionHandle);
  1214. if (!avatar.IsChildAgent)
  1215. avatar.ControllingClient.Kick("The simulator is going down.");
  1216. avatar.ControllingClient.SendShutdownConnectionNotice();
  1217. });
  1218. // Stop updating the scene objects and agents.
  1219. m_shuttingDown = true;
  1220. // Wait here, or the kick messages won't actually get to the agents before the scene terminates.
  1221. // We also need to wait to avoid a race condition with the scene update loop which might not yet
  1222. // have checked ShuttingDown.
  1223. Thread.Sleep(500);
  1224. // Stop all client threads.
  1225. ForEachScenePresence(delegate(ScenePresence avatar) { CloseAgent(avatar.UUID, false); });
  1226. m_log.Debug("[SCENE]: TriggerSceneShuttingDown");
  1227. EventManager.TriggerSceneShuttingDown(this);
  1228. m_log.Debug("[SCENE]: Persisting changed objects");
  1229. Backup(true);
  1230. m_log.Debug("[SCENE]: Closing scene");
  1231. m_sceneGraph.Close();
  1232. base.Close();
  1233. // XEngine currently listens to the EventManager.OnShutdown event to trigger script stop and persistence.
  1234. // Therefore. we must dispose of the PhysicsScene after this to prevent a window where script code can
  1235. // attempt to reference a null or disposed physics scene.
  1236. if (PhysicsScene != null)
  1237. {
  1238. m_log.Debug("[SCENE]: Dispose Physics");
  1239. PhysicsScene phys = PhysicsScene;
  1240. // remove the physics engine from both Scene and SceneGraph
  1241. PhysicsScene = null;
  1242. phys.Dispose();
  1243. phys = null;
  1244. }
  1245. }
  1246. public override void Start()
  1247. {
  1248. Start(true);
  1249. }
  1250. /// <summary>
  1251. /// Start the scene
  1252. /// </summary>
  1253. /// <param name='startScripts'>
  1254. /// Start the scripts within the scene.
  1255. /// </param>
  1256. public void Start(bool startScripts)
  1257. {
  1258. if (IsRunning)
  1259. return;
  1260. m_isRunning = true;
  1261. m_active = true;
  1262. m_unixStartTime = Util.UnixTimeSinceEpoch();
  1263. // m_log.DebugFormat("[SCENE]: Starting Heartbeat timer for {0}", RegionInfo.RegionName);
  1264. if (m_heartbeatThread != null)
  1265. {
  1266. m_hbRestarts++;
  1267. if(m_hbRestarts > 10)
  1268. Environment.Exit(1);
  1269. m_log.ErrorFormat("[SCENE]: Restarting heartbeat thread because it hasn't reported in in region {0}", RegionInfo.RegionName);
  1270. //int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
  1271. //System.Diagnostics.Process proc = new System.Diagnostics.Process();
  1272. //proc.EnableRaisingEvents=false;
  1273. //proc.StartInfo.FileName = "/bin/kill";
  1274. //proc.StartInfo.Arguments = "-QUIT " + pid.ToString();
  1275. //proc.Start();
  1276. //proc.WaitForExit();
  1277. //Thread.Sleep(1000);
  1278. //Environment.Exit(1);
  1279. m_heartbeatThread.Abort();
  1280. Watchdog.AbortThread(m_heartbeatThread.ManagedThreadId);
  1281. m_heartbeatThread = null;
  1282. }
  1283. GC.Collect();
  1284. GC.WaitForPendingFinalizers();
  1285. GC.Collect();
  1286. // tell physics to finish building actor
  1287. m_sceneGraph.ProcessPhysicsPreSimulation();
  1288. m_heartbeatThread = WorkManager.StartThread(
  1289. Heartbeat, string.Format("Heartbeat-({0})", RegionInfo.RegionName.Replace(" ", "_")), ThreadPriority.Normal, false,
  1290. false, null, 20000, false);
  1291. StartScripts();
  1292. }
  1293. /// <summary>
  1294. /// Sets up references to modules required by the scene
  1295. /// </summary>
  1296. public void SetModuleInterfaces()
  1297. {
  1298. m_xmlrpcModule = RequestModuleInterface<IXMLRPC>();
  1299. m_worldCommModule = RequestModuleInterface<IWorldComm>();
  1300. XferManager = RequestModuleInterface<IXfer>();
  1301. m_AvatarFactory = RequestModuleInterface<IAvatarFactoryModule>();
  1302. AttachmentsModule = RequestModuleInterface<IAttachmentsModule>();
  1303. m_serialiser = RequestModuleInterface<IRegionSerialiserModule>();
  1304. m_dialogModule = RequestModuleInterface<IDialogModule>();
  1305. m_capsModule = RequestModuleInterface<ICapabilitiesModule>();
  1306. EntityTransferModule = RequestModuleInterface<IEntityTransferModule>();
  1307. m_groupsModule = RequestModuleInterface<IGroupsModule>();
  1308. AgentTransactionsModule = RequestModuleInterface<IAgentAssetTransactions>();
  1309. UserManagementModule = RequestModuleInterface<IUserManagement>();
  1310. }
  1311. #endregion
  1312. #region Update Methods
  1313. /// <summary>
  1314. /// Activate the various loops necessary to continually update the scene.
  1315. /// </summary>
  1316. private void Heartbeat()
  1317. {
  1318. m_eventManager.TriggerOnRegionStarted(this);
  1319. // The first frame can take a very long time due to physics actors being added on startup. Therefore,
  1320. // don't turn on the watchdog alarm for this thread until the second frame, in order to prevent false
  1321. // alarms for scenes with many objects.
  1322. Update(1);
  1323. Watchdog.GetCurrentThreadInfo().AlarmIfTimeout = true;
  1324. m_lastFrameTick = Util.EnvironmentTickCount();
  1325. Update(-1);
  1326. Watchdog.RemoveThread();
  1327. }
  1328. public override void Update(int frames)
  1329. {
  1330. long? endFrame = null;
  1331. if (frames >= 0)
  1332. endFrame = Frame + frames;
  1333. float physicsFPS = 0f;
  1334. float frameTimeMS = FrameTime * 1000.0f;
  1335. int previousFrameTick;
  1336. double tmpMS;
  1337. double tmpMS2;
  1338. double framestart;
  1339. float sleepMS;
  1340. float sleepError = 0;
  1341. while (!m_shuttingDown && ((endFrame == null && Active) || Frame < endFrame))
  1342. {
  1343. framestart = Util.GetTimeStampMS();
  1344. ++Frame;
  1345. // m_log.DebugFormat("[SCENE]: Processing frame {0} in {1}", Frame, RegionInfo.RegionName);
  1346. agentMS = tempOnRezMS = eventMS = backupMS = terrainMS = landMS = 0f;
  1347. try
  1348. {
  1349. EventManager.TriggerRegionHeartbeatStart(this);
  1350. // Apply taints in terrain module to terrain in physics scene
  1351. tmpMS = Util.GetTimeStampMS();
  1352. if (Frame % 4 == 0)
  1353. {
  1354. CheckTerrainUpdates();
  1355. }
  1356. if (Frame % m_update_terrain == 0)
  1357. {
  1358. UpdateTerrain();
  1359. }
  1360. tmpMS2 = Util.GetTimeStampMS();
  1361. terrainMS = (float)(tmpMS2 - tmpMS);
  1362. tmpMS = tmpMS2;
  1363. if (PhysicsEnabled && Frame % m_update_physics == 0)
  1364. m_sceneGraph.UpdatePreparePhysics();
  1365. tmpMS2 = Util.GetTimeStampMS();
  1366. physicsMS2 = (float)(tmpMS2 - tmpMS);
  1367. tmpMS = tmpMS2;
  1368. /*
  1369. // Apply any pending avatar force input to the avatar's velocity
  1370. if (Frame % m_update_entitymovement == 0)
  1371. m_sceneGraph.UpdateScenePresenceMovement();
  1372. */
  1373. if (Frame % (m_update_coarse_locations) == 0 && !m_sendingCoarseLocations)
  1374. {
  1375. m_sendingCoarseLocations = true;
  1376. WorkManager.RunInThreadPool(
  1377. delegate
  1378. {
  1379. List<Vector3> coarseLocations;
  1380. List<UUID> avatarUUIDs;
  1381. SceneGraph.GetCoarseLocations(out coarseLocations, out avatarUUIDs, 60);
  1382. // Send coarse locations to clients
  1383. ForEachScenePresence(delegate(ScenePresence presence)
  1384. {
  1385. presence.SendCoarseLocations(coarseLocations, avatarUUIDs);
  1386. });
  1387. m_sendingCoarseLocations = false;
  1388. }, null, string.Format("SendCoarseLocations ({0})", Name));
  1389. }
  1390. // Get the simulation frame time that the avatar force input
  1391. // took
  1392. tmpMS2 = Util.GetTimeStampMS();
  1393. agentMS = (float)(tmpMS2 - tmpMS);
  1394. tmpMS = tmpMS2;
  1395. // Perform the main physics update. This will do the actual work of moving objects and avatars according to their
  1396. // velocity
  1397. if (Frame % m_update_physics == 0)
  1398. {
  1399. if (PhysicsEnabled)
  1400. physicsFPS = m_sceneGraph.UpdatePhysics(FrameTime);
  1401. if (SynchronizeScene != null)
  1402. SynchronizeScene(this);
  1403. }
  1404. tmpMS2 = Util.GetTimeStampMS();
  1405. physicsMS = (float)(tmpMS2 - tmpMS);
  1406. tmpMS = tmpMS2;
  1407. // Check if any objects have reached their targets
  1408. CheckAtTargets();
  1409. // Update SceneObjectGroups that have scheduled themselves for updates
  1410. // Objects queue their updates onto all scene presences
  1411. if (Frame % m_update_objects == 0)
  1412. m_sceneGraph.UpdateObjectGroups();
  1413. // Run through all ScenePresences looking for updates
  1414. // Presence updates and queued object updates for each presence are sent to clients
  1415. if (Frame % m_update_presences == 0)
  1416. m_sceneGraph.UpdatePresences();
  1417. tmpMS2 = Util.GetTimeStampMS();
  1418. agentMS += (float)(tmpMS2 - tmpMS);
  1419. tmpMS = tmpMS2;
  1420. // Delete temp-on-rez stuff
  1421. if (Frame % m_update_temp_cleaning == 0 && !m_cleaningTemps)
  1422. {
  1423. m_cleaningTemps = true;
  1424. WorkManager.RunInThreadPool(
  1425. delegate { CleanTempObjects(); m_cleaningTemps = false; }, null, string.Format("CleanTempObjects ({0})", Name));
  1426. tmpMS2 = Util.GetTimeStampMS();
  1427. tempOnRezMS = (float)(tmpMS2 - tmpMS); // bad.. counts the FireAndForget, not CleanTempObjects
  1428. tmpMS = tmpMS2;
  1429. }
  1430. if (Frame % m_update_events == 0)
  1431. {
  1432. UpdateEvents();
  1433. tmpMS2 = Util.GetTimeStampMS();
  1434. eventMS = (float)(tmpMS2 - tmpMS);
  1435. tmpMS = tmpMS2;
  1436. }
  1437. if (PeriodicBackup && Frame % m_update_backup == 0)
  1438. {
  1439. UpdateStorageBackup();
  1440. tmpMS2 = Util.GetTimeStampMS();
  1441. backupMS = (float)(tmpMS2 - tmpMS);
  1442. tmpMS = tmpMS2;
  1443. }
  1444. //if (Frame % m_update_land == 0)
  1445. //{
  1446. // int ldMS = Util.EnvironmentTickCount();
  1447. // UpdateLand();
  1448. // landMS = Util.EnvironmentTickCountSubtract(ldMS);
  1449. //}
  1450. if (!LoginsEnabled && Frame == 20)
  1451. {
  1452. GC.Collect();
  1453. GC.WaitForPendingFinalizers();
  1454. GC.Collect();
  1455. if (!LoginLock)
  1456. {
  1457. if (!StartDisabled)
  1458. {
  1459. m_log.InfoFormat("[REGION]: Enabling logins for {0}", RegionInfo.RegionName);
  1460. LoginsEnabled = true;
  1461. }
  1462. m_sceneGridService.InformNeighborsThatRegionisUp(
  1463. RequestModuleInterface<INeighbourService>(), RegionInfo);
  1464. // Region ready should always be set
  1465. Ready = true;
  1466. }
  1467. else
  1468. {
  1469. // This handles a case of a region having no scripts for the RegionReady module
  1470. if (m_sceneGraph.GetActiveScriptsCount() == 0)
  1471. {
  1472. // In this case, we leave it to the IRegionReadyModule to enable logins
  1473. // LoginLock can currently only be set by a region module implementation.
  1474. // If somehow this hasn't been done then the quickest way to bugfix is to see the
  1475. // NullReferenceException
  1476. IRegionReadyModule rrm = RequestModuleInterface<IRegionReadyModule>();
  1477. rrm.TriggerRegionReady(this);
  1478. }
  1479. }
  1480. }
  1481. }
  1482. catch (Exception e)
  1483. {
  1484. m_log.ErrorFormat(
  1485. "[SCENE]: Failed on region {0} with exception {1}{2}",
  1486. RegionInfo.RegionName, e.Message, e.StackTrace);
  1487. }
  1488. EventManager.TriggerRegionHeartbeatEnd(this);
  1489. m_firstHeartbeat = false;
  1490. Watchdog.UpdateThread();
  1491. otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
  1492. tmpMS = Util.GetTimeStampMS();
  1493. previousFrameTick = m_lastFrameTick;
  1494. m_lastFrameTick = (int)(tmpMS + 0.5);
  1495. // estimate sleep time
  1496. tmpMS2 = tmpMS - framestart;
  1497. tmpMS2 = (double)frameTimeMS - tmpMS2 - sleepError;
  1498. // reuse frameMS as temporary
  1499. frameMS = (float)tmpMS2;
  1500. // sleep if we can
  1501. if (tmpMS2 > 0)
  1502. {
  1503. Thread.Sleep((int)(tmpMS2 + 0.5));
  1504. tmpMS2 = Util.GetTimeStampMS();
  1505. sleepMS = (float)(tmpMS2 - tmpMS);
  1506. sleepError = sleepMS - frameMS;
  1507. Util.Clamp(sleepError, 0.0f, 20f);
  1508. frameMS = (float)(tmpMS2 - framestart);
  1509. }
  1510. else
  1511. {
  1512. tmpMS2 = Util.GetTimeStampMS();
  1513. frameMS = (float)(tmpMS2 - framestart);
  1514. sleepMS = 0.0f;
  1515. sleepError = 0.0f;
  1516. }
  1517. // script time is not scene frame time, but is displayed per frame
  1518. float scriptTimeMS = GetAndResetScriptExecutionTime();
  1519. StatsReporter.AddFrameStats(TimeDilation, physicsFPS, agentMS,
  1520. physicsMS + physicsMS2, otherMS , sleepMS, frameMS, scriptTimeMS);
  1521. // if (Frame%m_update_avatars == 0)
  1522. // UpdateInWorldTime();
  1523. // Optionally warn if a frame takes double the amount of time that it should.
  1524. if (DebugUpdates
  1525. && Util.EnvironmentTickCountSubtract(
  1526. m_lastFrameTick, previousFrameTick) > (int)(FrameTime * 1000 * 2))
  1527. m_log.WarnFormat(
  1528. "[SCENE]: Frame took {0} ms (desired max {1} ms) in {2}",
  1529. Util.EnvironmentTickCountSubtract(m_lastFrameTick, previousFrameTick),
  1530. FrameTime * 1000,
  1531. RegionInfo.RegionName);
  1532. }
  1533. }
  1534. /// <summary>
  1535. /// Adds the execution time of one script to the total scripts execution time for this region.
  1536. /// </summary>
  1537. /// <param name="ticks">Elapsed Stopwatch ticks</param>
  1538. public void AddScriptExecutionTime(long ticks)
  1539. {
  1540. StatsReporter.addScriptEvents(1);
  1541. Interlocked.Add(ref m_scriptExecutionTime, ticks);
  1542. }
  1543. /// <summary>
  1544. /// Returns the total execution time of all the scripts in the region since the last call
  1545. /// (in milliseconds), and clears the value in preparation for the next call.
  1546. /// </summary>
  1547. /// <returns>Time in milliseconds</returns>
  1548. // Warning: this is now called from StatsReporter, and can't be shared
  1549. public long GetAndResetScriptExecutionTime()
  1550. {
  1551. long ticks = Interlocked.Exchange(ref m_scriptExecutionTime, 0);
  1552. return (ticks * 1000L) / Stopwatch.Frequency;
  1553. }
  1554. public void AddGroupTarget(SceneObjectGroup grp)
  1555. {
  1556. lock (m_groupsWithTargets)
  1557. m_groupsWithTargets[grp.UUID] = 0;
  1558. }
  1559. public void RemoveGroupTarget(SceneObjectGroup grp)
  1560. {
  1561. lock (m_groupsWithTargets)
  1562. m_groupsWithTargets.Remove(grp.UUID);
  1563. }
  1564. private void CheckAtTargets()
  1565. {
  1566. List<UUID> objs = null;
  1567. lock (m_groupsWithTargets)
  1568. {
  1569. if (m_groupsWithTargets.Count != 0)
  1570. objs = new List<UUID>(m_groupsWithTargets.Keys);
  1571. }
  1572. if (objs != null)
  1573. {
  1574. foreach (UUID entry in objs)
  1575. {
  1576. SceneObjectGroup grp = GetSceneObjectGroup(entry);
  1577. if (grp == null)
  1578. m_groupsWithTargets.Remove(entry);
  1579. else
  1580. grp.checkAtTargets();
  1581. }
  1582. }
  1583. }
  1584. /// <summary>
  1585. /// Send out simstats data to all clients
  1586. /// </summary>
  1587. /// <param name="stats">Stats on the Simulator's performance</param>
  1588. private void SendSimStatsPackets(SimStats stats)
  1589. {
  1590. ForEachRootClient(delegate(IClientAPI client)
  1591. {
  1592. client.SendSimStats(stats);
  1593. });
  1594. }
  1595. /// <summary>
  1596. /// Update the terrain if it needs to be updated.
  1597. /// </summary>
  1598. private void UpdateTerrain()
  1599. {
  1600. EventManager.TriggerTerrainTick();
  1601. }
  1602. private void CheckTerrainUpdates()
  1603. {
  1604. EventManager.TriggerTerrainCheckUpdates();
  1605. }
  1606. /// <summary>
  1607. /// Back up queued up changes
  1608. /// </summary>
  1609. private void UpdateStorageBackup()
  1610. {
  1611. if (!m_backingup)
  1612. {
  1613. WorkManager.RunInThreadPool(o => Backup(false), null, string.Format("BackupWorker ({0})", Name), false);
  1614. }
  1615. }
  1616. /// <summary>
  1617. /// Sends out the OnFrame event to the modules
  1618. /// </summary>
  1619. private void UpdateEvents()
  1620. {
  1621. m_eventManager.TriggerOnFrame();
  1622. }
  1623. /// <summary>
  1624. /// Backup the scene.
  1625. /// </summary>
  1626. /// <remarks>
  1627. /// This acts as the main method of the backup thread. In a regression test whether the backup thread is not
  1628. /// running independently this can be invoked directly.
  1629. /// </remarks>
  1630. /// <param name="forced">
  1631. /// If true, then any changes that have not yet been persisted are persisted. If false,
  1632. /// then the persistence decision is left to the backup code (in some situations, such as object persistence,
  1633. /// it's much more efficient to backup multiple changes at once rather than every single one).
  1634. /// <returns></returns>
  1635. public void Backup(bool forced)
  1636. {
  1637. lock (m_returns)
  1638. {
  1639. if(m_backingup)
  1640. {
  1641. m_log.WarnFormat("[Scene] Backup of {0} already running. New call skipped", RegionInfo.RegionName);
  1642. return;
  1643. }
  1644. m_backingup = true;
  1645. try
  1646. {
  1647. EventManager.TriggerOnBackup(SimulationDataService, forced);
  1648. if(m_returns.Count == 0)
  1649. return;
  1650. IMessageTransferModule tr = RequestModuleInterface<IMessageTransferModule>();
  1651. if (tr == null)
  1652. return;
  1653. uint unixtime = (uint)Util.UnixTimeSinceEpoch();
  1654. uint estateid = RegionInfo.EstateSettings.ParentEstateID;
  1655. Guid regionguid = RegionInfo.RegionID.Guid;
  1656. foreach (KeyValuePair<UUID, ReturnInfo> ret in m_returns)
  1657. {
  1658. GridInstantMessage msg = new GridInstantMessage();
  1659. msg.fromAgentID = Guid.Empty; // From server
  1660. msg.toAgentID = ret.Key.Guid;
  1661. msg.imSessionID = Guid.NewGuid();
  1662. msg.timestamp = unixtime;
  1663. msg.fromAgentName = "Server";
  1664. msg.dialog = 19; // Object msg
  1665. msg.fromGroup = false;
  1666. msg.offline = 1;
  1667. msg.ParentEstateID = estateid;
  1668. msg.Position = Vector3.Zero;
  1669. msg.RegionID = regionguid;
  1670. // We must fill in a null-terminated 'empty' string here since bytes[0] will crash viewer 3.
  1671. msg.binaryBucket = new Byte[1] {0};
  1672. if (ret.Value.count > 1)
  1673. msg.message = string.Format("Your {0} objects were returned from {1} in region {2} due to {3}", ret.Value.count, ret.Value.location.ToString(), RegionInfo.RegionName, ret.Value.reason);
  1674. else
  1675. msg.message = string.Format("Your object {0} was returned from {1} in region {2} due to {3}", ret.Value.objectName, ret.Value.location.ToString(), RegionInfo.RegionName, ret.Value.reason);
  1676. tr.SendInstantMessage(msg, delegate(bool success) { });
  1677. }
  1678. m_returns.Clear();
  1679. }
  1680. finally
  1681. {
  1682. m_backingup = false;
  1683. }
  1684. }
  1685. }
  1686. /// <summary>
  1687. /// Synchronous force backup. For deletes and links/unlinks
  1688. /// </summary>
  1689. /// <param name="group">Object to be backed up</param>
  1690. public void ForceSceneObjectBackup(SceneObjectGroup group)
  1691. {
  1692. if (group != null)
  1693. {
  1694. group.HasGroupChanged = true;
  1695. group.ProcessBackup(SimulationDataService, true);
  1696. }
  1697. }
  1698. /// <summary>
  1699. /// Tell an agent that their object has been returned.
  1700. /// </summary>
  1701. /// <remarks>
  1702. /// The actual return is handled by the caller.
  1703. /// </remarks>
  1704. /// <param name="agentID">Avatar Unique Id</param>
  1705. /// <param name="objectName">Name of object returned</param>
  1706. /// <param name="location">Location of object returned</param>
  1707. /// <param name="reason">Reasion for object return</param>
  1708. public void AddReturn(UUID agentID, string objectName, Vector3 location, string reason)
  1709. {
  1710. lock (m_returns)
  1711. {
  1712. if (m_returns.ContainsKey(agentID))
  1713. {
  1714. ReturnInfo info = m_returns[agentID];
  1715. info.count++;
  1716. m_returns[agentID] = info;
  1717. }
  1718. else
  1719. {
  1720. ReturnInfo info = new ReturnInfo();
  1721. info.count = 1;
  1722. info.objectName = objectName;
  1723. info.location = location;
  1724. info.reason = reason;
  1725. m_returns[agentID] = info;
  1726. }
  1727. }
  1728. }
  1729. #endregion
  1730. #region Load Terrain
  1731. /// <summary>
  1732. /// Store the terrain in the persistant data store
  1733. /// </summary>
  1734. public void SaveTerrain()
  1735. {
  1736. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1737. }
  1738. /// <summary>
  1739. /// Store the terrain in the persistant data store
  1740. /// </summary>
  1741. public void SaveBakedTerrain()
  1742. {
  1743. if(Bakedmap != null)
  1744. SimulationDataService.StoreBakedTerrain(Bakedmap.GetTerrainData(), RegionInfo.RegionID);
  1745. }
  1746. public void StoreWindlightProfile(RegionLightShareData wl)
  1747. {
  1748. RegionInfo.WindlightSettings = wl;
  1749. SimulationDataService.StoreRegionWindlightSettings(wl);
  1750. m_eventManager.TriggerOnSaveNewWindlightProfile();
  1751. }
  1752. public void LoadWindlightProfile()
  1753. {
  1754. RegionInfo.WindlightSettings = SimulationDataService.LoadRegionWindlightSettings(RegionInfo.RegionID);
  1755. m_eventManager.TriggerOnSaveNewWindlightProfile();
  1756. }
  1757. /// <summary>
  1758. /// Loads the World heightmap
  1759. /// </summary>
  1760. public override void LoadWorldMap()
  1761. {
  1762. try
  1763. {
  1764. Bakedmap = null;
  1765. TerrainData map = SimulationDataService.LoadBakedTerrain(RegionInfo.RegionID, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
  1766. if (map != null)
  1767. {
  1768. Bakedmap = new TerrainChannel(map);
  1769. }
  1770. }
  1771. catch (Exception e)
  1772. {
  1773. m_log.WarnFormat(
  1774. "[TERRAIN]: Scene.cs: LoadWorldMap() baked terrain - Failed with exception {0}{1}", e.Message, e.StackTrace);
  1775. }
  1776. try
  1777. {
  1778. TerrainData map = SimulationDataService.LoadTerrain(RegionInfo.RegionID, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
  1779. if (map == null)
  1780. {
  1781. if(Bakedmap != null)
  1782. {
  1783. m_log.Warn("[TERRAIN]: terrain not found. Used stored baked terrain.");
  1784. Heightmap = Bakedmap.MakeCopy();
  1785. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1786. }
  1787. else
  1788. {
  1789. // This should be in the Terrain module, but it isn't because
  1790. // the heightmap is needed _way_ before the modules are initialized...
  1791. IConfig terrainConfig = m_config.Configs["Terrain"];
  1792. String m_InitialTerrain = "pinhead-island";
  1793. if (terrainConfig != null)
  1794. m_InitialTerrain = terrainConfig.GetString("InitialTerrain", m_InitialTerrain);
  1795. m_log.InfoFormat("[TERRAIN]: No default terrain. Generating a new terrain {0}.", m_InitialTerrain);
  1796. Heightmap = new TerrainChannel(m_InitialTerrain, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
  1797. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1798. }
  1799. }
  1800. else
  1801. {
  1802. Heightmap = new TerrainChannel(map);
  1803. }
  1804. }
  1805. catch (IOException e)
  1806. {
  1807. m_log.WarnFormat(
  1808. "[TERRAIN]: Scene.cs: LoadWorldMap() - Regenerating as failed with exception {0}{1}",
  1809. e.Message, e.StackTrace);
  1810. #pragma warning disable 0162
  1811. if ((int)Constants.RegionSize != 256)
  1812. {
  1813. Heightmap = new TerrainChannel();
  1814. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1815. }
  1816. }
  1817. catch (Exception e)
  1818. {
  1819. m_log.WarnFormat(
  1820. "[TERRAIN]: Scene.cs: LoadWorldMap() - Failed with exception {0}{1}", e.Message, e.StackTrace);
  1821. }
  1822. if(Bakedmap == null && Heightmap != null)
  1823. {
  1824. Bakedmap = Heightmap.MakeCopy();
  1825. SimulationDataService.StoreBakedTerrain(Bakedmap.GetTerrainData(), RegionInfo.RegionID);
  1826. }
  1827. }
  1828. /// <summary>
  1829. /// Register this region with a grid service
  1830. /// </summary>
  1831. /// <exception cref="System.Exception">Thrown if registration of the region itself fails.</exception>
  1832. public void RegisterRegionWithGrid()
  1833. {
  1834. m_sceneGridService.SetScene(this);
  1835. //// Unfortunately this needs to be here and it can't be async.
  1836. //// The map tile image is stored in RegionSettings, but it also needs to be
  1837. //// stored in the GridService, because that's what the world map module uses
  1838. //// to send the map image UUIDs (of other regions) to the viewer...
  1839. if (m_generateMaptiles)
  1840. RegenerateMaptile();
  1841. GridRegion region = new GridRegion(RegionInfo);
  1842. string error = GridService.RegisterRegion(RegionInfo.ScopeID, region);
  1843. // m_log.DebugFormat("[SCENE]: RegisterRegionWithGrid. name={0},id={1},loc=<{2},{3}>,size=<{4},{5}>",
  1844. // m_regionName,
  1845. // RegionInfo.RegionID,
  1846. // RegionInfo.RegionLocX, RegionInfo.RegionLocY,
  1847. // RegionInfo.RegionSizeX, RegionInfo.RegionSizeY);
  1848. if (error != String.Empty)
  1849. throw new Exception(error);
  1850. }
  1851. #endregion
  1852. #region Load Land
  1853. /// <summary>
  1854. /// Loads all Parcel data from the datastore for region identified by regionID
  1855. /// </summary>
  1856. /// <param name="regionID">Unique Identifier of the Region to load parcel data for</param>
  1857. public void loadAllLandObjectsFromStorage(UUID regionID)
  1858. {
  1859. m_log.Info("[SCENE]: Loading land objects from storage");
  1860. List<LandData> landData = SimulationDataService.LoadLandObjects(regionID);
  1861. if (LandChannel != null)
  1862. {
  1863. if (landData.Count == 0)
  1864. {
  1865. EventManager.TriggerNoticeNoLandDataFromStorage();
  1866. }
  1867. else
  1868. {
  1869. EventManager.TriggerIncomingLandDataFromStorage(landData);
  1870. }
  1871. }
  1872. else
  1873. {
  1874. m_log.Error("[SCENE]: Land Channel is not defined. Cannot load from storage!");
  1875. }
  1876. }
  1877. #endregion
  1878. #region Primitives Methods
  1879. /// <summary>
  1880. /// Loads the World's objects
  1881. /// </summary>
  1882. /// <param name="regionID"></param>
  1883. public virtual void LoadPrimsFromStorage(UUID regionID)
  1884. {
  1885. LoadingPrims = true;
  1886. m_log.Info("[SCENE]: Loading objects from datastore");
  1887. List<SceneObjectGroup> PrimsFromDB = SimulationDataService.LoadObjects(regionID);
  1888. m_log.InfoFormat("[SCENE]: Loaded {0} objects from the datastore", PrimsFromDB.Count);
  1889. foreach (SceneObjectGroup group in PrimsFromDB)
  1890. {
  1891. AddRestoredSceneObject(group, true, true);
  1892. EventManager.TriggerOnSceneObjectLoaded(group);
  1893. SceneObjectPart rootPart = group.GetPart(group.UUID);
  1894. rootPart.Flags &= ~PrimFlags.Scripted;
  1895. rootPart.TrimPermissions();
  1896. group.InvalidateDeepEffectivePerms();
  1897. // Don't do this here - it will get done later on when sculpt data is loaded.
  1898. // group.CheckSculptAndLoad();
  1899. }
  1900. LoadingPrims = false;
  1901. EventManager.TriggerPrimsLoaded(this);
  1902. }
  1903. public bool SupportsRayCastFiltered()
  1904. {
  1905. if (PhysicsScene == null)
  1906. return false;
  1907. return PhysicsScene.SupportsRaycastWorldFiltered();
  1908. }
  1909. public object RayCastFiltered(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
  1910. {
  1911. if (PhysicsScene == null)
  1912. return null;
  1913. return PhysicsScene.RaycastWorld(position, direction, length, Count, filter);
  1914. }
  1915. /// <summary>
  1916. /// Gets a new rez location based on the raycast and the size of the object that is being rezzed.
  1917. /// </summary>
  1918. /// <param name="RayStart"></param>
  1919. /// <param name="RayEnd"></param>
  1920. /// <param name="RayTargetID"></param>
  1921. /// <param name="rot"></param>
  1922. /// <param name="bypassRayCast"></param>
  1923. /// <param name="RayEndIsIntersection"></param>
  1924. /// <param name="frontFacesOnly"></param>
  1925. /// <param name="scale"></param>
  1926. /// <param name="FaceCenter"></param>
  1927. /// <returns></returns>
  1928. public Vector3 GetNewRezLocation(Vector3 RayStart, Vector3 RayEnd, UUID RayTargetID, Quaternion rot, byte bypassRayCast, byte RayEndIsIntersection, bool frontFacesOnly, Vector3 scale, bool FaceCenter)
  1929. {
  1930. Vector3 dir = RayEnd - RayStart;
  1931. float wheight = (float)RegionInfo.RegionSettings.WaterHeight;
  1932. Vector3 wpos = Vector3.Zero;
  1933. // Check for water surface intersection from above
  1934. if ((RayStart.Z > wheight) && (RayEnd.Z < wheight))
  1935. {
  1936. float ratio = (wheight - RayStart.Z) / dir.Z;
  1937. wpos.X = RayStart.X + (ratio * dir.X);
  1938. wpos.Y = RayStart.Y + (ratio * dir.Y);
  1939. wpos.Z = wheight;
  1940. }
  1941. Vector3 pos = Vector3.Zero;
  1942. if (RayEndIsIntersection != (byte)1)
  1943. {
  1944. float dist = dir.Length();
  1945. if (dist != 0)
  1946. {
  1947. Vector3 direction = dir * (1 / dist);
  1948. dist += 1.0f;
  1949. if (SupportsRayCastFiltered())
  1950. {
  1951. RayFilterFlags rayfilter = RayFilterFlags.BackFaceCull;
  1952. rayfilter |= RayFilterFlags.land;
  1953. rayfilter |= RayFilterFlags.physical;
  1954. rayfilter |= RayFilterFlags.nonphysical;
  1955. rayfilter |= RayFilterFlags.LSLPhantom; // ubODE will only see volume detectors
  1956. // get some more contacts ???
  1957. int physcount = 4;
  1958. List<ContactResult> physresults =
  1959. (List<ContactResult>)RayCastFiltered(RayStart, direction, dist, physcount, rayfilter);
  1960. if (physresults != null && physresults.Count > 0)
  1961. {
  1962. // look for terrain ?
  1963. if(RayTargetID == UUID.Zero)
  1964. {
  1965. foreach (ContactResult r in physresults)
  1966. {
  1967. if (r.ConsumerID == 0)
  1968. {
  1969. pos = r.Normal * scale;
  1970. pos *= 0.5f;
  1971. pos = r.Pos + pos;
  1972. if (wpos.Z > pos.Z) pos = wpos;
  1973. return pos;
  1974. }
  1975. }
  1976. }
  1977. else
  1978. {
  1979. foreach (ContactResult r in physresults)
  1980. {
  1981. SceneObjectPart part = GetSceneObjectPart(r.ConsumerID);
  1982. if (part == null)
  1983. continue;
  1984. if (part.UUID == RayTargetID)
  1985. {
  1986. pos = r.Normal * scale;
  1987. pos *= 0.5f;
  1988. pos = r.Pos + pos;
  1989. if (wpos.Z > pos.Z) pos = wpos;
  1990. return pos;
  1991. }
  1992. }
  1993. }
  1994. // else the first we got
  1995. pos = physresults[0].Normal * scale;
  1996. pos *= 0.5f;
  1997. pos = physresults[0].Pos + pos;
  1998. if (wpos.Z > pos.Z)
  1999. pos = wpos;
  2000. return pos;
  2001. }
  2002. }
  2003. if (RayTargetID != UUID.Zero)
  2004. {
  2005. SceneObjectPart target = GetSceneObjectPart(RayTargetID);
  2006. Ray NewRay = new Ray(RayStart, direction);
  2007. if (target != null)
  2008. {
  2009. pos = target.AbsolutePosition;
  2010. // Ray Trace against target here
  2011. EntityIntersection ei = target.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, FaceCenter);
  2012. // Un-comment out the following line to Get Raytrace results printed to the console.
  2013. // m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
  2014. float ScaleOffset = 0.5f;
  2015. // If we hit something
  2016. if (ei.HitTF)
  2017. {
  2018. Vector3 scaleComponent = ei.AAfaceNormal;
  2019. if (scaleComponent.X != 0) ScaleOffset = scale.X;
  2020. if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
  2021. if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
  2022. ScaleOffset = Math.Abs(ScaleOffset);
  2023. Vector3 intersectionpoint = ei.ipoint;
  2024. Vector3 normal = ei.normal;
  2025. // Set the position to the intersection point
  2026. Vector3 offset = (normal * (ScaleOffset / 2f));
  2027. pos = (intersectionpoint + offset);
  2028. //Seems to make no sense to do this as this call is used for rezzing from inventory as well, and with inventory items their size is not always 0.5f
  2029. //And in cases when we weren't rezzing from inventory we were re-adding the 0.25 straight after calling this method
  2030. // Un-offset the prim (it gets offset later by the consumer method)
  2031. //pos.Z -= 0.25F;
  2032. if (wpos.Z > pos.Z) pos = wpos;
  2033. return pos;
  2034. }
  2035. }
  2036. else
  2037. {
  2038. // We don't have a target here, so we're going to raytrace all the objects in the scene.
  2039. EntityIntersection ei = m_sceneGraph.GetClosestIntersectingPrim(NewRay, true, false);
  2040. // Un-comment the following line to print the raytrace results to the console.
  2041. //m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
  2042. if (ei.HitTF)
  2043. {
  2044. pos = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
  2045. }
  2046. else
  2047. {
  2048. // fall back to our stupid functionality
  2049. pos = RayEnd;
  2050. }
  2051. if (wpos.Z > pos.Z) pos = wpos;
  2052. return pos;
  2053. }
  2054. }
  2055. }
  2056. }
  2057. // fall back to our stupid functionality
  2058. pos = RayEnd;
  2059. //increase height so its above the ground.
  2060. //should be getting the normal of the ground at the rez point and using that?
  2061. pos.Z += scale.Z / 2f;
  2062. // return pos;
  2063. // check against posible water intercept
  2064. if (wpos.Z > pos.Z) pos = wpos;
  2065. return pos;
  2066. }
  2067. /// <summary>
  2068. /// Create a New SceneObjectGroup/Part by raycasting
  2069. /// </summary>
  2070. /// <param name="ownerID"></param>
  2071. /// <param name="groupID"></param>
  2072. /// <param name="RayEnd"></param>
  2073. /// <param name="rot"></param>
  2074. /// <param name="shape"></param>
  2075. /// <param name="bypassRaycast"></param>
  2076. /// <param name="RayStart"></param>
  2077. /// <param name="RayTargetID"></param>
  2078. /// <param name="RayEndIsIntersection"></param>
  2079. public virtual void AddNewPrim(UUID ownerID, UUID groupID, Vector3 RayEnd, Quaternion rot, PrimitiveBaseShape shape,
  2080. byte bypassRaycast, Vector3 RayStart, UUID RayTargetID,
  2081. byte RayEndIsIntersection)
  2082. {
  2083. Vector3 pos = GetNewRezLocation(RayStart, RayEnd, RayTargetID, rot, bypassRaycast, RayEndIsIntersection, true, new Vector3(0.5f, 0.5f, 0.5f), false);
  2084. if (Permissions.CanRezObject(1, ownerID, pos))
  2085. {
  2086. // rez ON the ground, not IN the ground
  2087. // pos.Z += 0.25F; The rez point should now be correct so that its not in the ground
  2088. AddNewPrim(ownerID, groupID, pos, rot, shape);
  2089. }
  2090. else
  2091. {
  2092. IClientAPI client = null;
  2093. if (TryGetClient(ownerID, out client))
  2094. client.SendAlertMessage("You cannot create objects here.");
  2095. }
  2096. }
  2097. public virtual SceneObjectGroup AddNewPrim(
  2098. UUID ownerID, UUID groupID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape)
  2099. {
  2100. //m_log.DebugFormat(
  2101. // "[SCENE]: Scene.AddNewPrim() pcode {0} called for {1} in {2}", shape.PCode, ownerID, RegionInfo.RegionName);
  2102. SceneObjectGroup sceneObject = null;
  2103. // If an entity creator has been registered for this prim type then use that
  2104. if (m_entityCreators.ContainsKey((PCode)shape.PCode))
  2105. {
  2106. sceneObject = m_entityCreators[(PCode)shape.PCode].CreateEntity(ownerID, groupID, pos, rot, shape);
  2107. }
  2108. else
  2109. {
  2110. // Otherwise, use this default creation code;
  2111. sceneObject = new SceneObjectGroup(ownerID, pos, rot, shape);
  2112. sceneObject.SetGroup(groupID, null);
  2113. AddNewSceneObject(sceneObject, true);
  2114. if (AgentPreferencesService != null) // This will override the brave new full perm world!
  2115. {
  2116. AgentPrefs prefs = AgentPreferencesService.GetAgentPreferences(ownerID);
  2117. // Only apply user selected prefs if the user set them
  2118. if (prefs != null && prefs.PermNextOwner != 0)
  2119. {
  2120. sceneObject.RootPart.GroupMask = (uint)prefs.PermGroup;
  2121. sceneObject.RootPart.EveryoneMask = (uint)prefs.PermEveryone;
  2122. sceneObject.RootPart.NextOwnerMask = (uint)prefs.PermNextOwner;
  2123. }
  2124. }
  2125. }
  2126. if (UserManagementModule != null)
  2127. sceneObject.RootPart.CreatorIdentification = UserManagementModule.GetUserUUI(ownerID);
  2128. sceneObject.InvalidateDeepEffectivePerms();;
  2129. sceneObject.ScheduleGroupForFullAnimUpdate();
  2130. return sceneObject;
  2131. }
  2132. /// <summary>
  2133. /// Add an object into the scene that has come from storage
  2134. /// </summary>
  2135. ///
  2136. /// <param name="sceneObject"></param>
  2137. /// <param name="attachToBackup">
  2138. /// If true, changes to the object will be reflected in its persisted data
  2139. /// If false, the persisted data will not be changed even if the object in the scene is changed
  2140. /// </param>
  2141. /// <param name="alreadyPersisted">
  2142. /// If true, we won't persist this object until it changes
  2143. /// If false, we'll persist this object immediately
  2144. /// </param>
  2145. /// <param name="sendClientUpdates">
  2146. /// If true, we send updates to the client to tell it about this object
  2147. /// If false, we leave it up to the caller to do this
  2148. /// </param>
  2149. /// <returns>
  2150. /// true if the object was added, false if an object with the same uuid was already in the scene
  2151. /// </returns>
  2152. public bool AddRestoredSceneObject(
  2153. SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
  2154. {
  2155. if (m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates))
  2156. {
  2157. sceneObject.IsDeleted = false;
  2158. EventManager.TriggerObjectAddedToScene(sceneObject);
  2159. return true;
  2160. }
  2161. return false;
  2162. }
  2163. /// <summary>
  2164. /// Add an object into the scene that has come from storage
  2165. /// </summary>
  2166. ///
  2167. /// <param name="sceneObject"></param>
  2168. /// <param name="attachToBackup">
  2169. /// If true, changes to the object will be reflected in its persisted data
  2170. /// If false, the persisted data will not be changed even if the object in the scene is changed
  2171. /// </param>
  2172. /// <param name="alreadyPersisted">
  2173. /// If true, we won't persist this object until it changes
  2174. /// If false, we'll persist this object immediately
  2175. /// </param>
  2176. /// <returns>
  2177. /// true if the object was added, false if an object with the same uuid was already in the scene
  2178. /// </returns>
  2179. public bool AddRestoredSceneObject(
  2180. SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted)
  2181. {
  2182. return AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, true);
  2183. }
  2184. /// <summary>
  2185. /// Add a newly created object to the scene. Updates are also sent to viewers.
  2186. /// </summary>
  2187. /// <param name="sceneObject"></param>
  2188. /// <param name="attachToBackup">
  2189. /// If true, the object is made persistent into the scene.
  2190. /// If false, the object will not persist over server restarts
  2191. /// </param>
  2192. /// <returns>true if the object was added. false if not</returns>
  2193. public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup)
  2194. {
  2195. return AddNewSceneObject(sceneObject, attachToBackup, true);
  2196. }
  2197. /// <summary>
  2198. /// Add a newly created object to the scene
  2199. /// </summary>
  2200. /// <param name="sceneObject"></param>
  2201. /// <param name="attachToBackup">
  2202. /// If true, the object is made persistent into the scene.
  2203. /// If false, the object will not persist over server restarts
  2204. /// </param>
  2205. /// <param name="sendClientUpdates">
  2206. /// If true, updates for the new scene object are sent to all viewers in range.
  2207. /// If false, it is left to the caller to schedule the update
  2208. /// </param>
  2209. /// <returns>true if the object was added. false if not</returns>
  2210. public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates)
  2211. {
  2212. if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, sendClientUpdates))
  2213. {
  2214. EventManager.TriggerObjectAddedToScene(sceneObject);
  2215. return true;
  2216. }
  2217. return false;
  2218. }
  2219. /// <summary>
  2220. /// Add a newly created object to the scene.
  2221. /// </summary>
  2222. /// <remarks>
  2223. /// This method does not send updates to the client - callers need to handle this themselves.
  2224. /// </remarks>
  2225. /// <param name="sceneObject"></param>
  2226. /// <param name="attachToBackup"></param>
  2227. /// <param name="pos">Position of the object. If null then the position stored in the object is used.</param>
  2228. /// <param name="rot">Rotation of the object. If null then the rotation stored in the object is used.</param>
  2229. /// <param name="vel">Velocity of the object. This parameter only has an effect if the object is physical</param>
  2230. /// <returns></returns>
  2231. public bool AddNewSceneObject(
  2232. SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel)
  2233. {
  2234. if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel))
  2235. {
  2236. EventManager.TriggerObjectAddedToScene(sceneObject);
  2237. return true;
  2238. }
  2239. return false;
  2240. }
  2241. /// <summary>
  2242. /// Delete every object from the scene. This does not include attachments worn by avatars.
  2243. /// </summary>
  2244. public void DeleteAllSceneObjects()
  2245. {
  2246. DeleteAllSceneObjects(false);
  2247. }
  2248. /// <summary>
  2249. /// Delete every object from the scene. This does not include attachments worn by avatars.
  2250. /// </summary>
  2251. public void DeleteAllSceneObjects(bool exceptNoCopy)
  2252. {
  2253. List<SceneObjectGroup> toReturn = new List<SceneObjectGroup>();
  2254. lock (Entities)
  2255. {
  2256. EntityBase[] entities = Entities.GetEntities();
  2257. foreach (EntityBase e in entities)
  2258. {
  2259. if (e is SceneObjectGroup)
  2260. {
  2261. SceneObjectGroup sog = (SceneObjectGroup)e;
  2262. if (sog != null && !sog.IsAttachment)
  2263. {
  2264. if (!exceptNoCopy || ((sog.EffectiveOwnerPerms & (uint)PermissionMask.Copy) != 0))
  2265. {
  2266. DeleteSceneObject((SceneObjectGroup)e, false);
  2267. }
  2268. else
  2269. {
  2270. toReturn.Add((SceneObjectGroup)e);
  2271. }
  2272. }
  2273. }
  2274. }
  2275. }
  2276. if (toReturn.Count > 0)
  2277. {
  2278. returnObjects(toReturn.ToArray(), null);
  2279. }
  2280. }
  2281. /// <summary>
  2282. /// Synchronously delete the given object from the scene.
  2283. /// </summary>
  2284. /// <remarks>
  2285. /// Scripts are also removed.
  2286. /// </remarks>
  2287. /// <param name="group">Object Id</param>
  2288. /// <param name="silent">Suppress broadcasting changes to other clients.</param>
  2289. public void DeleteSceneObject(SceneObjectGroup group, bool silent)
  2290. {
  2291. DeleteSceneObject(group, silent, true);
  2292. }
  2293. /// <summary>
  2294. /// Synchronously delete the given object from the scene.
  2295. /// </summary>
  2296. /// <param name="group">Object Id</param>
  2297. /// <param name="silent">Suppress broadcasting changes to other clients.</param>
  2298. /// <param name="removeScripts">If true, then scripts are removed. If false, then they are only stopped.</para>
  2299. public void DeleteSceneObject(SceneObjectGroup group, bool silent, bool removeScripts)
  2300. {
  2301. // m_log.DebugFormat("[SCENE]: Deleting scene object {0} {1}", group.Name, group.UUID);
  2302. if (removeScripts)
  2303. group.RemoveScriptInstances(true);
  2304. else
  2305. group.StopScriptInstances();
  2306. SceneObjectPart[] partList = group.Parts;
  2307. foreach (SceneObjectPart part in partList)
  2308. {
  2309. if (part.KeyframeMotion != null)
  2310. {
  2311. part.KeyframeMotion.Delete();
  2312. part.KeyframeMotion = null;
  2313. }
  2314. if (part.IsJoint() && ((part.Flags & PrimFlags.Physics) != 0))
  2315. {
  2316. PhysicsScene.RequestJointDeletion(part.Name); // FIXME: what if the name changed?
  2317. }
  2318. else if (part.PhysActor != null)
  2319. {
  2320. part.RemoveFromPhysics();
  2321. }
  2322. }
  2323. if (UnlinkSceneObject(group, false))
  2324. {
  2325. EventManager.TriggerObjectBeingRemovedFromScene(group);
  2326. EventManager.TriggerParcelPrimCountTainted();
  2327. }
  2328. group.DeleteGroupFromScene(silent);
  2329. // use this to mean also full delete
  2330. if (removeScripts)
  2331. group.Clear();
  2332. partList = null;
  2333. // m_log.DebugFormat("[SCENE]: Exit DeleteSceneObject() for {0} {1}", group.Name, group.UUID);
  2334. }
  2335. /// <summary>
  2336. /// Unlink the given object from the scene. Unlike delete, this just removes the record of the object - the
  2337. /// object itself is not destroyed.
  2338. /// </summary>
  2339. /// <param name="so">The scene object.</param>
  2340. /// <param name="softDelete">If true, only deletes from scene, but keeps the object in the database.</param>
  2341. /// <returns>true if the object was in the scene, false if it was not</returns>
  2342. public bool UnlinkSceneObject(SceneObjectGroup so, bool softDelete)
  2343. {
  2344. if (m_sceneGraph.DeleteSceneObject(so.UUID, softDelete))
  2345. {
  2346. if (!softDelete)
  2347. {
  2348. // If the group contains prims whose SceneGroupID is incorrect then force a
  2349. // database update, because RemoveObject() works by searching on the SceneGroupID.
  2350. // This is an expensive thing to do so only do it if absolutely necessary.
  2351. if (so.GroupContainsForeignPrims)
  2352. ForceSceneObjectBackup(so);
  2353. so.DetachFromBackup();
  2354. SimulationDataService.RemoveObject(so.UUID, RegionInfo.RegionID);
  2355. }
  2356. // We need to keep track of this state in case this group is still queued for further backup.
  2357. so.IsDeleted = true;
  2358. return true;
  2359. }
  2360. return false;
  2361. }
  2362. /* not in use, outdate by async method
  2363. /// <summary>
  2364. /// Move the given scene object into a new region depending on which region its absolute position has moved
  2365. /// into.
  2366. ///
  2367. /// </summary>
  2368. /// <param name="attemptedPosition">the attempted out of region position of the scene object</param>
  2369. /// <param name="grp">the scene object that we're crossing</param>
  2370. public void CrossPrimGroupIntoNewRegion(Vector3 attemptedPosition, SceneObjectGroup grp, bool silent)
  2371. {
  2372. if (grp == null)
  2373. return;
  2374. if (grp.IsDeleted)
  2375. return;
  2376. if (grp.RootPart.DIE_AT_EDGE)
  2377. {
  2378. // We remove the object here
  2379. try
  2380. {
  2381. DeleteSceneObject(grp, false);
  2382. }
  2383. catch (Exception)
  2384. {
  2385. m_log.Warn("[SCENE]: exception when trying to remove the prim that crossed the border.");
  2386. }
  2387. return;
  2388. }
  2389. if (grp.RootPart.RETURN_AT_EDGE)
  2390. {
  2391. // We remove the object here
  2392. try
  2393. {
  2394. List<SceneObjectGroup> objects = new List<SceneObjectGroup>();
  2395. objects.Add(grp);
  2396. SceneObjectGroup[] objectsArray = objects.ToArray();
  2397. returnObjects(objectsArray, UUID.Zero);
  2398. }
  2399. catch (Exception)
  2400. {
  2401. m_log.Warn("[SCENE]: exception when trying to return the prim that crossed the border.");
  2402. }
  2403. return;
  2404. }
  2405. if (EntityTransferModule != null)
  2406. EntityTransferModule.Cross(grp, attemptedPosition, silent);
  2407. }
  2408. */
  2409. // Simple test to see if a position is in the current region.
  2410. // This test is mostly used to see if a region crossing is necessary.
  2411. // Assuming the position is relative to the region so anything outside its bounds.
  2412. // Return 'true' if position inside region.
  2413. public bool PositionIsInCurrentRegion(Vector3 pos)
  2414. {
  2415. float t = pos.X;
  2416. if (t < 0 || t >= RegionInfo.RegionSizeX)
  2417. return false;
  2418. t = pos.Y;
  2419. if (t < 0 || t >= RegionInfo.RegionSizeY)
  2420. return false;
  2421. return true;
  2422. }
  2423. /// <summary>
  2424. /// Called when objects or attachments cross the border, or teleport, between regions.
  2425. /// </summary>
  2426. /// <param name="sog"></param>
  2427. /// <returns></returns>
  2428. public bool IncomingCreateObject(Vector3 newPosition, ISceneObject sog)
  2429. {
  2430. //m_log.DebugFormat(" >>> IncomingCreateObject(sog) <<< {0} deleted? {1} isAttach? {2}", ((SceneObjectGroup)sog).AbsolutePosition,
  2431. // ((SceneObjectGroup)sog).IsDeleted, ((SceneObjectGroup)sog).RootPart.IsAttachment);
  2432. SceneObjectGroup newObject;
  2433. try
  2434. {
  2435. newObject = (SceneObjectGroup)sog;
  2436. }
  2437. catch (Exception e)
  2438. {
  2439. m_log.WarnFormat("[INTERREGION]: Problem casting object, exception {0}{1}", e.Message, e.StackTrace);
  2440. return false;
  2441. }
  2442. if (!EntityTransferModule.HandleIncomingSceneObject(newObject, newPosition))
  2443. return false;
  2444. // Do this as late as possible so that listeners have full access to the incoming object
  2445. EventManager.TriggerOnIncomingSceneObject(newObject);
  2446. return true;
  2447. }
  2448. /// <summary>
  2449. /// Adds a Scene Object group to the Scene.
  2450. /// Verifies that the creator of the object is not banned from the simulator.
  2451. /// Checks if the item is an Attachment
  2452. /// </summary>
  2453. /// <param name="sceneObject"></param>
  2454. /// <returns>True if the SceneObjectGroup was added, False if it was not</returns>
  2455. public bool AddSceneObject(SceneObjectGroup sceneObject)
  2456. {
  2457. if (sceneObject.OwnerID == UUID.Zero)
  2458. {
  2459. m_log.ErrorFormat("[SCENE]: Owner ID for {0} was zero", sceneObject.UUID);
  2460. return false;
  2461. }
  2462. // If the user is banned, we won't let any of their objects
  2463. // enter. Period.
  2464. //
  2465. int flags = GetUserFlags(sceneObject.OwnerID);
  2466. if (RegionInfo.EstateSettings.IsBanned(sceneObject.OwnerID, flags))
  2467. {
  2468. m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", sceneObject.OwnerID);
  2469. return false;
  2470. }
  2471. // Force allocation of new LocalId
  2472. //
  2473. SceneObjectPart[] parts = sceneObject.Parts;
  2474. for (int i = 0; i < parts.Length; i++)
  2475. parts[i].LocalId = 0;
  2476. if (sceneObject.IsAttachmentCheckFull()) // Attachment
  2477. {
  2478. sceneObject.RootPart.AddFlag(PrimFlags.TemporaryOnRez);
  2479. // sceneObject.RootPart.AddFlag(PrimFlags.Phantom);
  2480. // Don't sent a full update here because this will cause full updates to be sent twice for
  2481. // attachments on region crossings, resulting in viewer glitches.
  2482. AddRestoredSceneObject(sceneObject, false, false, false);
  2483. // Handle attachment special case
  2484. SceneObjectPart RootPrim = sceneObject.RootPart;
  2485. // Fix up attachment Parent Local ID
  2486. ScenePresence sp = GetScenePresence(sceneObject.OwnerID);
  2487. if (sp != null)
  2488. {
  2489. SceneObjectGroup grp = sceneObject;
  2490. // m_log.DebugFormat(
  2491. // "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.FromItemID, grp.UUID);
  2492. // m_log.DebugFormat(
  2493. // "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
  2494. RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
  2495. // We must currently not resume scripts at this stage since AttachmentsModule does not have the
  2496. // information that this is due to a teleport/border cross rather than an ordinary attachment.
  2497. // We currently do this in Scene.MakeRootAgent() instead.
  2498. if (AttachmentsModule != null)
  2499. AttachmentsModule.AttachObject(sp, grp, 0, false, false, true);
  2500. }
  2501. else
  2502. {
  2503. m_log.DebugFormat("[SCENE]: Attachment {0} arrived and scene presence was not found, setting to temp", sceneObject.UUID);
  2504. // RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
  2505. // RootPrim.AddFlag(PrimFlags.TemporaryOnRez);
  2506. }
  2507. if (sceneObject.OwnerID == UUID.Zero)
  2508. {
  2509. m_log.ErrorFormat("[SCENE]: Owner ID for {0} was zero after attachment processing. BUG!", sceneObject.UUID);
  2510. return false;
  2511. }
  2512. }
  2513. else
  2514. {
  2515. if (sceneObject.OwnerID == UUID.Zero)
  2516. {
  2517. m_log.ErrorFormat("[SCENE]: Owner ID for non-attachment {0} was zero", sceneObject.UUID);
  2518. return false;
  2519. }
  2520. AddRestoredSceneObject(sceneObject, true, false);
  2521. }
  2522. return true;
  2523. }
  2524. private int GetStateSource(SceneObjectGroup sog)
  2525. {
  2526. if(!sog.IsAttachmentCheckFull())
  2527. return 2; // StateSource.PrimCrossing
  2528. ScenePresence sp = GetScenePresence(sog.OwnerID);
  2529. if (sp != null)
  2530. return sp.GetStateSource();
  2531. return 2; // StateSource.PrimCrossing
  2532. }
  2533. public int GetUserFlags(UUID user)
  2534. {
  2535. //Unfortunately the SP approach means that the value is cached until region is restarted
  2536. /*
  2537. ScenePresence sp;
  2538. if (TryGetScenePresence(user, out sp))
  2539. {
  2540. return sp.UserFlags;
  2541. }
  2542. else
  2543. {
  2544. */
  2545. UserAccount uac = UserAccountService.GetUserAccount(RegionInfo.ScopeID, user);
  2546. if (uac == null)
  2547. return 0;
  2548. return uac.UserFlags;
  2549. //}
  2550. }
  2551. #endregion
  2552. #region Add/Remove Avatar Methods
  2553. public override ISceneAgent AddNewAgent(IClientAPI client, PresenceType type)
  2554. {
  2555. ScenePresence sp;
  2556. bool vialogin;
  2557. bool reallyNew = true;
  2558. // Update the number of users attempting to login
  2559. StatsReporter.UpdateUsersLoggingIn(true);
  2560. // Validation occurs in LLUDPServer
  2561. //
  2562. // XXX: A race condition exists here where two simultaneous calls to AddNewAgent can interfere with
  2563. // each other. In practice, this does not currently occur in the code.
  2564. AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
  2565. // We lock here on AgentCircuitData to prevent a race condition between the thread adding a new connection
  2566. // and a simultaneous one that removes it (as can happen if the client is closed at a particular point
  2567. // whilst connecting).
  2568. //
  2569. // It would be easier to lock across all NewUserConnection(), AddNewAgent() and
  2570. // RemoveClient() calls for all agents, but this would allow a slow call (e.g. because of slow service
  2571. // response in some module listening to AddNewAgent()) from holding up unrelated agent calls.
  2572. //
  2573. // In practice, the lock (this) in LLUDPServer.AddNewClient() currently lock across all
  2574. // AddNewClient() operations (though not other ops).
  2575. // In the future this can be relieved once locking per agent (not necessarily on AgentCircuitData) is improved.
  2576. lock (aCircuit)
  2577. {
  2578. vialogin
  2579. = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
  2580. || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
  2581. CheckHeartbeat();
  2582. sp = GetScenePresence(client.AgentId);
  2583. if (sp == null)
  2584. {
  2585. m_log.DebugFormat(
  2586. "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}, tpflags: {4}",
  2587. client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos,
  2588. ((TPFlags)aCircuit.teleportFlags).ToString());
  2589. m_clientManager.Add(client);
  2590. SubscribeToClientEvents(client);
  2591. sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
  2592. sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
  2593. m_eventManager.TriggerOnNewPresence(sp);
  2594. }
  2595. else
  2596. {
  2597. // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
  2598. // client is for a root or child agent.
  2599. // XXX: This may be better set for a new client before that client is added to the client manager.
  2600. // But need to know what happens in the case where a ScenePresence is already present (and if this
  2601. // actually occurs).
  2602. m_log.WarnFormat(
  2603. "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
  2604. sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
  2605. reallyNew = false;
  2606. }
  2607. client.SceneAgent = sp;
  2608. // This is currently also being done earlier in NewUserConnection for real users to see if this
  2609. // resolves problems where HG agents are occasionally seen by others as "Unknown user" in chat and other
  2610. // places. However, we still need to do it here for NPCs.
  2611. CacheUserName(sp, aCircuit);
  2612. if (reallyNew)
  2613. EventManager.TriggerOnNewClient(client);
  2614. if (vialogin)
  2615. EventManager.TriggerOnClientLogin(client);
  2616. }
  2617. // User has logged into the scene so update the list of users logging
  2618. // in
  2619. StatsReporter.UpdateUsersLoggingIn(false);
  2620. m_LastLogin = Util.EnvironmentTickCount();
  2621. return sp;
  2622. }
  2623. /// <summary>
  2624. /// Returns the Home URI of the agent, or null if unknown.
  2625. /// </summary>
  2626. public string GetAgentHomeURI(UUID agentID)
  2627. {
  2628. AgentCircuitData circuit = AuthenticateHandler.GetAgentCircuitData(agentID);
  2629. if (circuit != null && circuit.ServiceURLs != null && circuit.ServiceURLs.ContainsKey("HomeURI"))
  2630. return circuit.ServiceURLs["HomeURI"].ToString();
  2631. else
  2632. return null;
  2633. }
  2634. /// <summary>
  2635. /// Cache the user name for later use.
  2636. /// </summary>
  2637. /// <param name="sp"></param>
  2638. /// <param name="aCircuit"></param>
  2639. private void CacheUserName(ScenePresence sp, AgentCircuitData aCircuit)
  2640. {
  2641. if (UserManagementModule != null)
  2642. {
  2643. string first = aCircuit.firstname, last = aCircuit.lastname;
  2644. if (sp != null && sp.PresenceType == PresenceType.Npc)
  2645. {
  2646. UserManagementModule.AddUser(aCircuit.AgentID, first, last, true);
  2647. }
  2648. else
  2649. {
  2650. string homeURL = string.Empty;
  2651. if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
  2652. homeURL = aCircuit.ServiceURLs["HomeURI"].ToString();
  2653. if (aCircuit.lastname.StartsWith("@"))
  2654. {
  2655. string[] parts = aCircuit.firstname.Split('.');
  2656. if (parts.Length >= 2)
  2657. {
  2658. first = parts[0];
  2659. last = parts[1];
  2660. }
  2661. }
  2662. UserManagementModule.AddUser(aCircuit.AgentID, first, last, homeURL);
  2663. }
  2664. }
  2665. }
  2666. private bool VerifyClient(AgentCircuitData aCircuit, System.Net.IPEndPoint ep, out bool vialogin)
  2667. {
  2668. vialogin = false;
  2669. // Do the verification here
  2670. if ((aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0)
  2671. {
  2672. m_log.DebugFormat("[SCENE]: Incoming client {0} {1} in region {2} via HG login", aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2673. vialogin = true;
  2674. IUserAgentVerificationModule userVerification = RequestModuleInterface<IUserAgentVerificationModule>();
  2675. if (userVerification != null && ep != null)
  2676. {
  2677. if (!userVerification.VerifyClient(aCircuit, ep.Address.ToString()))
  2678. {
  2679. // uh-oh, this is fishy
  2680. m_log.DebugFormat("[SCENE]: User Client Verification for {0} {1} in {2} returned false", aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2681. return false;
  2682. }
  2683. else
  2684. m_log.DebugFormat("[SCENE]: User Client Verification for {0} {1} in {2} returned true", aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2685. }
  2686. }
  2687. else if ((aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0)
  2688. {
  2689. m_log.DebugFormat("[SCENE]: Incoming client {0} {1} in region {2} via regular login. Client IP verification not performed.",
  2690. aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2691. vialogin = true;
  2692. }
  2693. return true;
  2694. }
  2695. // Called by Caps, on the first HTTP contact from the client
  2696. public override bool CheckClient(UUID agentID, System.Net.IPEndPoint ep)
  2697. {
  2698. AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(agentID);
  2699. if (aCircuit == null)
  2700. return false;
  2701. bool vialogin = false;
  2702. if (VerifyClient(aCircuit, ep, out vialogin))
  2703. return true;
  2704. // if it doesn't pass, we remove the agentcircuitdata altogether
  2705. // and the scene presence and the client, if they exist
  2706. try
  2707. {
  2708. ScenePresence sp = WaitGetScenePresence(agentID);
  2709. if (sp != null)
  2710. {
  2711. PresenceService.LogoutAgent(sp.ControllingClient.SessionId);
  2712. CloseAgent(sp.UUID, false);
  2713. }
  2714. // BANG! SLASH!
  2715. m_authenticateHandler.RemoveCircuit(agentID);
  2716. }
  2717. catch (Exception e)
  2718. {
  2719. m_log.DebugFormat("[SCENE]: Exception while closing aborted client: {0}", e.StackTrace);
  2720. }
  2721. return false;
  2722. }
  2723. /// <summary>
  2724. /// Register for events from the client
  2725. /// </summary>
  2726. /// <param name="client">The IClientAPI of the connected client</param>
  2727. public virtual void SubscribeToClientEvents(IClientAPI client)
  2728. {
  2729. SubscribeToClientTerrainEvents(client);
  2730. SubscribeToClientPrimEvents(client);
  2731. SubscribeToClientPrimRezEvents(client);
  2732. SubscribeToClientInventoryEvents(client);
  2733. SubscribeToClientTeleportEvents(client);
  2734. SubscribeToClientScriptEvents(client);
  2735. SubscribeToClientParcelEvents(client);
  2736. SubscribeToClientGridEvents(client);
  2737. SubscribeToClientNetworkEvents(client);
  2738. }
  2739. public virtual void SubscribeToClientTerrainEvents(IClientAPI client)
  2740. {
  2741. // client.OnRegionHandShakeReply += SendLayerData;
  2742. }
  2743. public virtual void SubscribeToClientPrimEvents(IClientAPI client)
  2744. {
  2745. client.OnUpdatePrimGroupPosition += m_sceneGraph.UpdatePrimGroupPosition;
  2746. client.OnUpdatePrimSinglePosition += m_sceneGraph.UpdatePrimSinglePosition;
  2747. client.onClientChangeObject += m_sceneGraph.ClientChangeObject;
  2748. client.OnUpdatePrimGroupRotation += m_sceneGraph.UpdatePrimGroupRotation;
  2749. client.OnUpdatePrimGroupMouseRotation += m_sceneGraph.UpdatePrimGroupRotation;
  2750. client.OnUpdatePrimSingleRotation += m_sceneGraph.UpdatePrimSingleRotation;
  2751. client.OnUpdatePrimSingleRotationPosition += m_sceneGraph.UpdatePrimSingleRotationPosition;
  2752. client.OnUpdatePrimScale += m_sceneGraph.UpdatePrimScale;
  2753. client.OnUpdatePrimGroupScale += m_sceneGraph.UpdatePrimGroupScale;
  2754. client.OnUpdateExtraParams += m_sceneGraph.UpdateExtraParam;
  2755. client.OnUpdatePrimShape += m_sceneGraph.UpdatePrimShape;
  2756. client.OnUpdatePrimTexture += m_sceneGraph.UpdatePrimTexture;
  2757. client.OnObjectRequest += RequestPrim;
  2758. client.OnObjectSelect += SelectPrim;
  2759. client.OnObjectDeselect += DeselectPrim;
  2760. client.OnDeRezObject += DeRezObjects;
  2761. client.OnObjectName += m_sceneGraph.PrimName;
  2762. client.OnObjectClickAction += m_sceneGraph.PrimClickAction;
  2763. client.OnObjectMaterial += m_sceneGraph.PrimMaterial;
  2764. client.OnLinkObjects += LinkObjects;
  2765. client.OnDelinkObjects += DelinkObjects;
  2766. client.OnObjectDuplicate += DuplicateObject;
  2767. client.OnObjectDuplicateOnRay += doObjectDuplicateOnRay;
  2768. client.OnUpdatePrimFlags += m_sceneGraph.UpdatePrimFlags;
  2769. client.OnRequestObjectPropertiesFamily += m_sceneGraph.RequestObjectPropertiesFamily;
  2770. client.OnObjectPermissions += HandleObjectPermissionsUpdate;
  2771. client.OnGrabObject += ProcessObjectGrab;
  2772. client.OnGrabUpdate += ProcessObjectGrabUpdate;
  2773. client.OnDeGrabObject += ProcessObjectDeGrab;
  2774. client.OnSpinStart += ProcessSpinStart;
  2775. client.OnSpinUpdate += ProcessSpinObject;
  2776. client.OnSpinStop += ProcessSpinObjectStop;
  2777. client.OnUndo += m_sceneGraph.HandleUndo;
  2778. client.OnRedo += m_sceneGraph.HandleRedo;
  2779. client.OnObjectDescription += m_sceneGraph.PrimDescription;
  2780. client.OnObjectIncludeInSearch += m_sceneGraph.MakeObjectSearchable;
  2781. client.OnObjectOwner += ObjectOwner;
  2782. client.OnObjectGroupRequest += HandleObjectGroupUpdate;
  2783. }
  2784. public virtual void SubscribeToClientPrimRezEvents(IClientAPI client)
  2785. {
  2786. client.OnAddPrim += AddNewPrim;
  2787. client.OnRezObject += RezObject;
  2788. }
  2789. public virtual void SubscribeToClientInventoryEvents(IClientAPI client)
  2790. {
  2791. client.OnLinkInventoryItem += HandleLinkInventoryItem;
  2792. client.OnCreateNewInventoryFolder += HandleCreateInventoryFolder;
  2793. client.OnUpdateInventoryFolder += HandleUpdateInventoryFolder;
  2794. client.OnMoveInventoryFolder += HandleMoveInventoryFolder; // 2; //!!
  2795. client.OnFetchInventoryDescendents += HandleFetchInventoryDescendents;
  2796. client.OnPurgeInventoryDescendents += HandlePurgeInventoryDescendents; // 2; //!!
  2797. client.OnFetchInventory += m_asyncInventorySender.HandleFetchInventory;
  2798. client.OnUpdateInventoryItem += UpdateInventoryItemAsset;
  2799. client.OnCopyInventoryItem += CopyInventoryItem;
  2800. client.OnMoveItemsAndLeaveCopy += MoveInventoryItemsLeaveCopy;
  2801. client.OnMoveInventoryItem += MoveInventoryItem;
  2802. client.OnRemoveInventoryItem += RemoveInventoryItem;
  2803. client.OnRemoveInventoryFolder += RemoveInventoryFolder;
  2804. client.OnRezScript += RezScript;
  2805. client.OnRequestTaskInventory += RequestTaskInventory;
  2806. client.OnRemoveTaskItem += RemoveTaskInventory;
  2807. client.OnUpdateTaskInventory += UpdateTaskInventory;
  2808. client.OnMoveTaskItem += ClientMoveTaskInventoryItem;
  2809. }
  2810. public virtual void SubscribeToClientTeleportEvents(IClientAPI client)
  2811. {
  2812. client.OnTeleportLocationRequest += RequestTeleportLocation;
  2813. }
  2814. public virtual void SubscribeToClientScriptEvents(IClientAPI client)
  2815. {
  2816. client.OnScriptReset += ProcessScriptReset;
  2817. client.OnGetScriptRunning += GetScriptRunning;
  2818. client.OnSetScriptRunning += SetScriptRunning;
  2819. }
  2820. public virtual void SubscribeToClientParcelEvents(IClientAPI client)
  2821. {
  2822. client.OnParcelReturnObjectsRequest += LandChannel.ReturnObjectsInParcel;
  2823. client.OnParcelSetOtherCleanTime += LandChannel.SetParcelOtherCleanTime;
  2824. client.OnParcelBuy += ProcessParcelBuy;
  2825. }
  2826. public virtual void SubscribeToClientGridEvents(IClientAPI client)
  2827. {
  2828. //client.OnNameFromUUIDRequest += HandleUUIDNameRequest;
  2829. client.OnMoneyTransferRequest += ProcessMoneyTransferRequest;
  2830. }
  2831. public virtual void SubscribeToClientNetworkEvents(IClientAPI client)
  2832. {
  2833. client.OnNetworkStatsUpdate += StatsReporter.AddPacketsStats;
  2834. client.OnViewerEffect += ProcessViewerEffect;
  2835. }
  2836. /// <summary>
  2837. /// Unsubscribe the client from events.
  2838. /// </summary>
  2839. /// FIXME: Not called anywhere!
  2840. /// <param name="client">The IClientAPI of the client</param>
  2841. public virtual void UnSubscribeToClientEvents(IClientAPI client)
  2842. {
  2843. UnSubscribeToClientTerrainEvents(client);
  2844. UnSubscribeToClientPrimEvents(client);
  2845. UnSubscribeToClientPrimRezEvents(client);
  2846. UnSubscribeToClientInventoryEvents(client);
  2847. UnSubscribeToClientTeleportEvents(client);
  2848. UnSubscribeToClientScriptEvents(client);
  2849. UnSubscribeToClientParcelEvents(client);
  2850. UnSubscribeToClientGridEvents(client);
  2851. UnSubscribeToClientNetworkEvents(client);
  2852. }
  2853. public virtual void UnSubscribeToClientTerrainEvents(IClientAPI client)
  2854. {
  2855. // client.OnRegionHandShakeReply -= SendLayerData;
  2856. }
  2857. public virtual void UnSubscribeToClientPrimEvents(IClientAPI client)
  2858. {
  2859. client.OnUpdatePrimGroupPosition -= m_sceneGraph.UpdatePrimGroupPosition;
  2860. client.OnUpdatePrimSinglePosition -= m_sceneGraph.UpdatePrimSinglePosition;
  2861. client.onClientChangeObject -= m_sceneGraph.ClientChangeObject;
  2862. client.OnUpdatePrimGroupRotation -= m_sceneGraph.UpdatePrimGroupRotation;
  2863. client.OnUpdatePrimGroupMouseRotation -= m_sceneGraph.UpdatePrimGroupRotation;
  2864. client.OnUpdatePrimSingleRotation -= m_sceneGraph.UpdatePrimSingleRotation;
  2865. client.OnUpdatePrimSingleRotationPosition -= m_sceneGraph.UpdatePrimSingleRotationPosition;
  2866. client.OnUpdatePrimScale -= m_sceneGraph.UpdatePrimScale;
  2867. client.OnUpdatePrimGroupScale -= m_sceneGraph.UpdatePrimGroupScale;
  2868. client.OnUpdateExtraParams -= m_sceneGraph.UpdateExtraParam;
  2869. client.OnUpdatePrimShape -= m_sceneGraph.UpdatePrimShape;
  2870. client.OnUpdatePrimTexture -= m_sceneGraph.UpdatePrimTexture;
  2871. client.OnObjectRequest -= RequestPrim;
  2872. client.OnObjectSelect -= SelectPrim;
  2873. client.OnObjectDeselect -= DeselectPrim;
  2874. client.OnDeRezObject -= DeRezObjects;
  2875. client.OnObjectName -= m_sceneGraph.PrimName;
  2876. client.OnObjectClickAction -= m_sceneGraph.PrimClickAction;
  2877. client.OnObjectMaterial -= m_sceneGraph.PrimMaterial;
  2878. client.OnLinkObjects -= LinkObjects;
  2879. client.OnDelinkObjects -= DelinkObjects;
  2880. client.OnObjectDuplicate -= DuplicateObject;
  2881. client.OnObjectDuplicateOnRay -= doObjectDuplicateOnRay;
  2882. client.OnUpdatePrimFlags -= m_sceneGraph.UpdatePrimFlags;
  2883. client.OnRequestObjectPropertiesFamily -= m_sceneGraph.RequestObjectPropertiesFamily;
  2884. client.OnObjectPermissions -= HandleObjectPermissionsUpdate;
  2885. client.OnGrabObject -= ProcessObjectGrab;
  2886. client.OnGrabUpdate -= ProcessObjectGrabUpdate;
  2887. client.OnDeGrabObject -= ProcessObjectDeGrab;
  2888. client.OnSpinStart -= ProcessSpinStart;
  2889. client.OnSpinUpdate -= ProcessSpinObject;
  2890. client.OnSpinStop -= ProcessSpinObjectStop;
  2891. client.OnUndo -= m_sceneGraph.HandleUndo;
  2892. client.OnRedo -= m_sceneGraph.HandleRedo;
  2893. client.OnObjectDescription -= m_sceneGraph.PrimDescription;
  2894. client.OnObjectIncludeInSearch -= m_sceneGraph.MakeObjectSearchable;
  2895. client.OnObjectOwner -= ObjectOwner;
  2896. }
  2897. public virtual void UnSubscribeToClientPrimRezEvents(IClientAPI client)
  2898. {
  2899. client.OnAddPrim -= AddNewPrim;
  2900. client.OnRezObject -= RezObject;
  2901. }
  2902. public virtual void UnSubscribeToClientInventoryEvents(IClientAPI client)
  2903. {
  2904. client.OnCreateNewInventoryFolder -= HandleCreateInventoryFolder;
  2905. client.OnUpdateInventoryFolder -= HandleUpdateInventoryFolder;
  2906. client.OnMoveInventoryFolder -= HandleMoveInventoryFolder; // 2; //!!
  2907. client.OnFetchInventoryDescendents -= HandleFetchInventoryDescendents;
  2908. client.OnPurgeInventoryDescendents -= HandlePurgeInventoryDescendents; // 2; //!!
  2909. client.OnFetchInventory -= m_asyncInventorySender.HandleFetchInventory;
  2910. client.OnUpdateInventoryItem -= UpdateInventoryItemAsset;
  2911. client.OnCopyInventoryItem -= CopyInventoryItem;
  2912. client.OnMoveInventoryItem -= MoveInventoryItem;
  2913. client.OnRemoveInventoryItem -= RemoveInventoryItem;
  2914. client.OnRemoveInventoryFolder -= RemoveInventoryFolder;
  2915. client.OnRezScript -= RezScript;
  2916. client.OnRequestTaskInventory -= RequestTaskInventory;
  2917. client.OnRemoveTaskItem -= RemoveTaskInventory;
  2918. client.OnUpdateTaskInventory -= UpdateTaskInventory;
  2919. client.OnMoveTaskItem -= ClientMoveTaskInventoryItem;
  2920. }
  2921. public virtual void UnSubscribeToClientTeleportEvents(IClientAPI client)
  2922. {
  2923. client.OnTeleportLocationRequest -= RequestTeleportLocation;
  2924. //client.OnTeleportLandmarkRequest -= RequestTeleportLandmark;
  2925. //client.OnTeleportHomeRequest -= TeleportClientHome;
  2926. }
  2927. public virtual void UnSubscribeToClientScriptEvents(IClientAPI client)
  2928. {
  2929. client.OnScriptReset -= ProcessScriptReset;
  2930. client.OnGetScriptRunning -= GetScriptRunning;
  2931. client.OnSetScriptRunning -= SetScriptRunning;
  2932. }
  2933. public virtual void UnSubscribeToClientParcelEvents(IClientAPI client)
  2934. {
  2935. client.OnParcelReturnObjectsRequest -= LandChannel.ReturnObjectsInParcel;
  2936. client.OnParcelSetOtherCleanTime -= LandChannel.SetParcelOtherCleanTime;
  2937. client.OnParcelBuy -= ProcessParcelBuy;
  2938. }
  2939. public virtual void UnSubscribeToClientGridEvents(IClientAPI client)
  2940. {
  2941. //client.OnNameFromUUIDRequest -= HandleUUIDNameRequest;
  2942. client.OnMoneyTransferRequest -= ProcessMoneyTransferRequest;
  2943. }
  2944. public virtual void UnSubscribeToClientNetworkEvents(IClientAPI client)
  2945. {
  2946. client.OnNetworkStatsUpdate -= StatsReporter.AddPacketsStats;
  2947. client.OnViewerEffect -= ProcessViewerEffect;
  2948. }
  2949. /// <summary>
  2950. /// Teleport an avatar to their home region
  2951. /// </summary>
  2952. /// <param name="agentId">The avatar's Unique ID</param>
  2953. /// <param name="client">The IClientAPI for the client</param>
  2954. public virtual bool TeleportClientHome(UUID agentId, IClientAPI client)
  2955. {
  2956. if (EntityTransferModule != null)
  2957. {
  2958. return EntityTransferModule.TeleportHome(agentId, client);
  2959. }
  2960. else
  2961. {
  2962. m_log.DebugFormat("[SCENE]: Unable to teleport user home: no AgentTransferModule is active");
  2963. client.SendTeleportFailed("Unable to perform teleports on this simulator.");
  2964. }
  2965. return false;
  2966. }
  2967. /// <summary>
  2968. /// Duplicates object specified by localID. This is the event handler for IClientAPI.
  2969. /// </summary>
  2970. /// <param name="originalPrim">ID of object to duplicate</param>
  2971. /// <param name="offset"></param>
  2972. /// <param name="flags"></param>
  2973. /// <param name="AgentID">Agent doing the duplication</param>
  2974. /// <param name="GroupID">Group of new object</param>
  2975. public void DuplicateObject(uint originalPrim, Vector3 offset, uint flags, UUID AgentID, UUID GroupID)
  2976. {
  2977. bool createSelected = (flags & (uint)PrimFlags.CreateSelected) != 0;
  2978. SceneObjectGroup copy = SceneGraph.DuplicateObject(originalPrim, offset, AgentID,
  2979. GroupID, Quaternion.Identity, createSelected);
  2980. if (copy != null)
  2981. EventManager.TriggerObjectAddedToScene(copy);
  2982. }
  2983. /// <summary>
  2984. /// Duplicates object specified by localID at position raycasted against RayTargetObject using
  2985. /// RayEnd and RayStart to determine what the angle of the ray is
  2986. /// </summary>
  2987. /// <param name="localID">ID of object to duplicate</param>
  2988. /// <param name="dupeFlags"></param>
  2989. /// <param name="AgentID">Agent doing the duplication</param>
  2990. /// <param name="GroupID">Group of new object</param>
  2991. /// <param name="RayTargetObj">The target of the Ray</param>
  2992. /// <param name="RayEnd">The ending of the ray (farthest away point)</param>
  2993. /// <param name="RayStart">The Beginning of the ray (closest point)</param>
  2994. /// <param name="BypassRaycast">Bool to bypass raycasting</param>
  2995. /// <param name="RayEndIsIntersection">The End specified is the place to add the object</param>
  2996. /// <param name="CopyCenters">Position the object at the center of the face that it's colliding with</param>
  2997. /// <param name="CopyRotates">Rotate the object the same as the localID object</param>
  2998. public void doObjectDuplicateOnRay(uint localID, uint dupeFlags, UUID AgentID, UUID GroupID,
  2999. UUID RayTargetObj, Vector3 RayEnd, Vector3 RayStart,
  3000. bool BypassRaycast, bool RayEndIsIntersection, bool CopyCenters, bool CopyRotates)
  3001. {
  3002. Vector3 pos;
  3003. const bool frontFacesOnly = true;
  3004. //m_log.Info("HITTARGET: " + RayTargetObj.ToString() + ", COPYTARGET: " + localID.ToString());
  3005. SceneObjectPart target = GetSceneObjectPart(localID);
  3006. SceneObjectPart target2 = GetSceneObjectPart(RayTargetObj);
  3007. bool createSelected = (dupeFlags & (uint)PrimFlags.CreateSelected) != 0;
  3008. if (target != null && target2 != null)
  3009. {
  3010. Vector3 direction = Vector3.Normalize(RayEnd - RayStart);
  3011. pos = target2.AbsolutePosition;
  3012. //m_log.Info("[OBJECT_REZ]: TargetPos: " + pos.ToString() + ", RayStart: " + RayStart.ToString() + ", RayEnd: " + RayEnd.ToString() + ", Volume: " + Util.GetDistanceTo(RayStart,RayEnd).ToString() + ", mag1: " + Util.GetMagnitude(RayStart).ToString() + ", mag2: " + Util.GetMagnitude(RayEnd).ToString());
  3013. // TODO: Raytrace better here
  3014. //EntityIntersection ei = m_sceneGraph.GetClosestIntersectingPrim(new Ray(AXOrigin, AXdirection));
  3015. Ray NewRay = new Ray(RayStart,direction);
  3016. // Ray Trace against target here
  3017. EntityIntersection ei = target2.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, CopyCenters);
  3018. // Un-comment out the following line to Get Raytrace results printed to the console.
  3019. //m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
  3020. float ScaleOffset = 0.5f;
  3021. // If we hit something
  3022. if (ei.HitTF)
  3023. {
  3024. Vector3 scale = target.Scale;
  3025. Vector3 scaleComponent = ei.AAfaceNormal;
  3026. if (scaleComponent.X != 0) ScaleOffset = scale.X;
  3027. if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
  3028. if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
  3029. ScaleOffset = Math.Abs(ScaleOffset);
  3030. Vector3 intersectionpoint = ei.ipoint;
  3031. Vector3 normal = ei.normal;
  3032. Vector3 offset = normal * (ScaleOffset / 2f);
  3033. pos = intersectionpoint + offset;
  3034. // stick in offset format from the original prim
  3035. pos = pos - target.ParentGroup.AbsolutePosition;
  3036. SceneObjectGroup copy;
  3037. if (CopyRotates)
  3038. {
  3039. Quaternion worldRot = target2.GetWorldRotation();
  3040. // SceneObjectGroup obj = m_sceneGraph.DuplicateObject(localID, pos, target.GetEffectiveObjectFlags(), AgentID, GroupID, worldRot);
  3041. copy = m_sceneGraph.DuplicateObject(localID, pos, AgentID, GroupID, worldRot, createSelected);
  3042. //obj.Rotation = worldRot;
  3043. //obj.UpdateGroupRotationR(worldRot);
  3044. }
  3045. else
  3046. {
  3047. copy = m_sceneGraph.DuplicateObject(localID, pos, AgentID, GroupID, Quaternion.Identity, createSelected);
  3048. }
  3049. if (copy != null)
  3050. EventManager.TriggerObjectAddedToScene(copy);
  3051. }
  3052. }
  3053. }
  3054. /// <summary>
  3055. /// Get the avatar appearance for the given client.
  3056. /// </summary>
  3057. /// <param name="client"></param>
  3058. /// <param name="appearance"></param>
  3059. public void GetAvatarAppearance(IClientAPI client, out AvatarAppearance appearance)
  3060. {
  3061. AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
  3062. if (aCircuit == null)
  3063. {
  3064. m_log.DebugFormat("[APPEARANCE] Client did not supply a circuit. Non-Linden? Creating default appearance.");
  3065. appearance = new AvatarAppearance();
  3066. return;
  3067. }
  3068. appearance = aCircuit.Appearance;
  3069. if (appearance == null)
  3070. {
  3071. m_log.DebugFormat("[APPEARANCE]: Appearance not found in {0}, returning default", RegionInfo.RegionName);
  3072. appearance = new AvatarAppearance();
  3073. }
  3074. }
  3075. /// <summary>
  3076. /// Remove the given client from the scene.
  3077. /// </summary>
  3078. /// <remarks>
  3079. /// Only clientstack code should call this directly. All other code should call IncomingCloseAgent() instead
  3080. /// to properly operate the state machine and avoid race conditions with other close requests (such as directly
  3081. /// from viewers).
  3082. /// </remarks>
  3083. /// <param name='agentID'>ID of agent to close</param>
  3084. /// <param name='closeChildAgents'>
  3085. /// Close the neighbour child agents associated with this client.
  3086. /// </param>
  3087. ///
  3088. private object m_removeClientPrivLock = new Object();
  3089. public void RemoveClient(UUID agentID, bool closeChildAgents)
  3090. {
  3091. AgentCircuitData acd = m_authenticateHandler.GetAgentCircuitData(agentID);
  3092. // Shouldn't be necessary since RemoveClient() is currently only called by IClientAPI.Close() which
  3093. // in turn is only called by Scene.IncomingCloseAgent() which checks whether the presence exists or not
  3094. // However, will keep for now just in case.
  3095. if (acd == null)
  3096. {
  3097. m_log.ErrorFormat(
  3098. "[SCENE]: No agent circuit found for {0} in {1}, aborting Scene.RemoveClient", agentID, Name);
  3099. return;
  3100. }
  3101. // TODO: Can we now remove this lock?
  3102. lock (m_removeClientPrivLock)
  3103. {
  3104. bool isChildAgent = false;
  3105. ScenePresence avatar = GetScenePresence(agentID);
  3106. // Shouldn't be necessary since RemoveClient() is currently only called by IClientAPI.Close() which
  3107. // in turn is only called by Scene.IncomingCloseAgent() which checks whether the presence exists or not
  3108. // However, will keep for now just in case.
  3109. if (avatar == null)
  3110. {
  3111. m_log.ErrorFormat(
  3112. "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
  3113. m_authenticateHandler.RemoveCircuit(agentID);
  3114. return;
  3115. }
  3116. try
  3117. {
  3118. isChildAgent = avatar.IsChildAgent;
  3119. m_log.DebugFormat(
  3120. "[SCENE]: Removing {0} agent {1} {2} from {3}",
  3121. isChildAgent ? "child" : "root", avatar.Name, agentID, Name);
  3122. // Don't do this to root agents, it's not nice for the viewer
  3123. if (closeChildAgents && isChildAgent)
  3124. {
  3125. // Tell a single agent to disconnect from the region.
  3126. // Let's do this via UDP
  3127. avatar.ControllingClient.SendShutdownConnectionNotice();
  3128. }
  3129. // Only applies to root agents.
  3130. if (avatar.ParentID != 0)
  3131. {
  3132. avatar.StandUp();
  3133. }
  3134. m_sceneGraph.removeUserCount(!isChildAgent);
  3135. // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
  3136. // unnecessary operations. This should go away once NPCs have no accompanying IClientAPI
  3137. if (closeChildAgents && CapsModule != null)
  3138. CapsModule.RemoveCaps(agentID, avatar.ControllingClient.CircuitCode);
  3139. if (closeChildAgents && !isChildAgent)
  3140. {
  3141. List<ulong> regions = avatar.KnownRegionHandles;
  3142. regions.Remove(RegionInfo.RegionHandle);
  3143. // This ends up being done asynchronously so that a logout isn't held up where there are many present but unresponsive neighbours.
  3144. m_sceneGridService.SendCloseChildAgentConnections(agentID, acd.SessionID.ToString(), regions);
  3145. }
  3146. m_eventManager.TriggerClientClosed(agentID, this);
  3147. // m_log.Debug("[Scene]TriggerClientClosed done");
  3148. m_eventManager.TriggerOnRemovePresence(agentID);
  3149. // m_log.Debug("[Scene]TriggerOnRemovePresence done");
  3150. if (!isChildAgent)
  3151. {
  3152. if (AttachmentsModule != null)
  3153. {
  3154. // m_log.Debug("[Scene]DeRezAttachments");
  3155. AttachmentsModule.DeRezAttachments(avatar);
  3156. // m_log.Debug("[Scene]DeRezAttachments done");
  3157. }
  3158. ForEachClient(
  3159. delegate(IClientAPI client)
  3160. {
  3161. //We can safely ignore null reference exceptions. It means the avatar is dead and cleaned up anyway
  3162. try { client.SendKillObject(new List<uint> { avatar.LocalId }); }
  3163. catch (NullReferenceException) { }
  3164. });
  3165. }
  3166. // It's possible for child agents to have transactions if changes are being made cross-border.
  3167. if (AgentTransactionsModule != null)
  3168. {
  3169. // m_log.Debug("[Scene]RemoveAgentAssetTransactions");
  3170. AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
  3171. }
  3172. m_log.Debug("[Scene] The avatar has left the building");
  3173. }
  3174. catch (Exception e)
  3175. {
  3176. m_log.Error(
  3177. string.Format("[SCENE]: Exception removing {0} from {1}. Cleaning up. Exception ", avatar.Name, Name), e);
  3178. }
  3179. finally
  3180. {
  3181. try
  3182. {
  3183. // Always clean these structures up so that any failure above doesn't cause them to remain in the
  3184. // scene with possibly bad effects (e.g. continually timing out on unacked packets and triggering
  3185. // the same cleanup exception continually.
  3186. m_authenticateHandler.RemoveCircuit(agentID);
  3187. m_sceneGraph.RemoveScenePresence(agentID);
  3188. m_clientManager.Remove(agentID);
  3189. avatar.Close();
  3190. }
  3191. catch (Exception e)
  3192. {
  3193. m_log.Error(
  3194. string.Format("[SCENE]: Exception in final clean up of {0} in {1}. Exception ", avatar.Name, Name), e);
  3195. }
  3196. }
  3197. }
  3198. //m_log.InfoFormat("[SCENE] Memory pre GC {0}", System.GC.GetTotalMemory(false));
  3199. //m_log.InfoFormat("[SCENE] Memory post GC {0}", System.GC.GetTotalMemory(true));
  3200. }
  3201. /// <summary>
  3202. /// Removes region from an avatar's known region list. This coincides with child agents. For each child agent, there will be a known region entry.
  3203. ///
  3204. /// </summary>
  3205. /// <param name="avatarID"></param>
  3206. /// <param name="regionslst"></param>
  3207. public void HandleRemoveKnownRegionsFromAvatar(UUID avatarID, List<ulong> regionslst)
  3208. {
  3209. ScenePresence av = GetScenePresence(avatarID);
  3210. if (av != null)
  3211. {
  3212. lock (av)
  3213. {
  3214. for (int i = 0; i < regionslst.Count; i++)
  3215. {
  3216. av.RemoveNeighbourRegion(regionslst[i]);
  3217. }
  3218. }
  3219. }
  3220. }
  3221. #endregion
  3222. #region Entities
  3223. public void SendKillObject(List<uint> localIDs)
  3224. {
  3225. List<uint> deleteIDs = new List<uint>();
  3226. foreach (uint localID in localIDs)
  3227. {
  3228. SceneObjectPart part = GetSceneObjectPart(localID);
  3229. if (part != null && part.ParentGroup != null &&
  3230. part.ParentGroup.RootPart == part)
  3231. deleteIDs.Add(localID);
  3232. }
  3233. ForEachClient(c => c.SendKillObject(deleteIDs));
  3234. }
  3235. #endregion
  3236. #region RegionComms
  3237. /// <summary>
  3238. /// Do the work necessary to initiate a new user connection for a particular scene.
  3239. /// </summary>
  3240. /// <param name="agent">CircuitData of the agent who is connecting</param>
  3241. /// <param name="teleportFlags"></param>
  3242. /// <param name="source">Source region (may be null)</param>
  3243. /// <param name="reason">Outputs the reason for the false response on this string</param>
  3244. /// <returns>True if the region accepts this agent. False if it does not. False will
  3245. /// also return a reason.</returns>
  3246. public bool NewUserConnection(AgentCircuitData agent, uint teleportFlags, GridRegion source, out string reason)
  3247. {
  3248. return NewUserConnection(agent, teleportFlags, source, out reason, true);
  3249. }
  3250. /// <summary>
  3251. /// Do the work necessary to initiate a new user connection for a particular scene.
  3252. /// </summary>
  3253. /// <remarks>
  3254. /// The return bool should allow for connections to be refused, but as not all calling paths
  3255. /// take proper notice of it yet, we still allowed banned users in.
  3256. ///
  3257. /// At the moment this method consists of setting up the caps infrastructure
  3258. /// The return bool should allow for connections to be refused, but as not all calling paths
  3259. /// take proper notice of it let, we allowed banned users in still.
  3260. ///
  3261. /// This method is called by the login service (in the case of login) or another simulator (in the case of region
  3262. /// cross or teleport) to initiate the connection. It is not triggered by the viewer itself - the connection
  3263. /// is activated later when the viewer sends the initial UseCircuitCodePacket UDP packet (in the case of
  3264. /// the LLUDP stack).
  3265. /// </remarks>
  3266. /// <param name="acd">CircuitData of the agent who is connecting</param>
  3267. /// <param name="source">Source region (may be null)</param>
  3268. /// <param name="reason">Outputs the reason for the false response on this string</param>
  3269. /// <param name="requirePresenceLookup">True for normal presence. False for NPC
  3270. /// or other applications where a full grid/Hypergrid presence may not be required.</param>
  3271. /// <returns>True if the region accepts this agent. False if it does not. False will
  3272. /// also return a reason.</returns>
  3273. ///
  3274. private object m_newUserConnLock = new object();
  3275. public bool NewUserConnection(AgentCircuitData acd, uint teleportFlags, GridRegion source, out string reason, bool requirePresenceLookup)
  3276. {
  3277. bool vialogin = ((teleportFlags & (uint)TPFlags.ViaLogin) != 0 ||
  3278. (teleportFlags & (uint)TPFlags.ViaHGLogin) != 0);
  3279. bool viahome = ((teleportFlags & (uint)TPFlags.ViaHome) != 0);
  3280. // bool godlike = ((teleportFlags & (uint)TPFlags.Godlike) != 0);
  3281. reason = String.Empty;
  3282. //Teleport flags:
  3283. //
  3284. // TeleportFlags.ViaGodlikeLure - Border Crossing
  3285. // TeleportFlags.ViaLogin - Login
  3286. // TeleportFlags.TeleportFlags.ViaLure - Teleport request sent by another user
  3287. // TeleportFlags.ViaLandmark | TeleportFlags.ViaLocation | TeleportFlags.ViaLandmark | TeleportFlags.Default - Regular Teleport
  3288. // Don't disable this log message - it's too helpful
  3289. string curViewer = Util.GetViewerName(acd);
  3290. m_log.DebugFormat(
  3291. "[SCENE]: Region {0} told of incoming {1} agent {2} {3} {4} (circuit code {5}, IP {6}, viewer {7}, teleportflags ({8}), position {9}. {10}",
  3292. RegionInfo.RegionName,
  3293. (acd.child ? "child" : "root"),
  3294. acd.firstname,
  3295. acd.lastname,
  3296. acd.AgentID,
  3297. acd.circuitcode,
  3298. acd.IPAddress,
  3299. curViewer,
  3300. ((TPFlags)teleportFlags).ToString(),
  3301. acd.startpos,
  3302. (source == null) ? "" : string.Format("From region {0} ({1}){2}", source.RegionName, source.RegionID, (source.RawServerURI == null) ? "" : " @ " + source.ServerURI)
  3303. );
  3304. // m_log.DebugFormat("NewUserConnection stack {0}", Environment.StackTrace);
  3305. if (!LoginsEnabled)
  3306. {
  3307. reason = "Logins to this region are disabled";
  3308. return false;
  3309. }
  3310. //Check if the viewer is banned or in the viewer access list
  3311. //We check if the substring is listed for higher flexebility
  3312. bool ViewerDenied = true;
  3313. //Check if the specific viewer is listed in the allowed viewer list
  3314. if (m_AllowedViewers.Count > 0)
  3315. {
  3316. foreach (string viewer in m_AllowedViewers)
  3317. {
  3318. if (viewer == curViewer.Substring(0, Math.Min(viewer.Length, curViewer.Length)).Trim().ToLower())
  3319. {
  3320. ViewerDenied = false;
  3321. break;
  3322. }
  3323. }
  3324. }
  3325. else
  3326. {
  3327. ViewerDenied = false;
  3328. }
  3329. //Check if the viewer is in the banned list
  3330. if (m_BannedViewers.Count > 0)
  3331. {
  3332. foreach (string viewer in m_BannedViewers)
  3333. {
  3334. if (viewer == curViewer.Substring(0, Math.Min(viewer.Length, curViewer.Length)).Trim().ToLower())
  3335. {
  3336. ViewerDenied = true;
  3337. break;
  3338. }
  3339. }
  3340. }
  3341. if (ViewerDenied)
  3342. {
  3343. m_log.DebugFormat(
  3344. "[SCENE]: Access denied for {0} {1} using {2}",
  3345. acd.firstname, acd.lastname, curViewer);
  3346. reason = "Access denied, your viewer is banned by the region owner";
  3347. return false;
  3348. }
  3349. ScenePresence sp;
  3350. lock (m_removeClientLock)
  3351. {
  3352. sp = GetScenePresence(acd.AgentID);
  3353. // We need to ensure that we are not already removing the scene presence before we ask it not to be
  3354. // closed.
  3355. if (sp != null && sp.IsChildAgent
  3356. && (sp.LifecycleState == ScenePresenceState.Running
  3357. || sp.LifecycleState == ScenePresenceState.PreRemove))
  3358. {
  3359. m_log.DebugFormat(
  3360. "[SCENE]: Reusing existing child scene presence for {0}, state {1} in {2}",
  3361. sp.Name, sp.LifecycleState, Name);
  3362. // In the case where, for example, an A B C D region layout, an avatar may
  3363. // teleport from A -> D, but then -> C before A has asked B to close its old child agent. When C
  3364. // renews the lease on the child agent at B, we must make sure that the close from A does not succeed.
  3365. //
  3366. // XXX: In the end, this should not be necessary if child agents are closed without delay on
  3367. // teleport, since realistically, the close request should always be processed before any other
  3368. // region tried to re-establish a child agent. This is much simpler since the logic below is
  3369. // vulnerable to an issue when a viewer quits a region without sending a proper logout but then
  3370. // re-establishes the connection on a relogin. This could wrongly set the DoNotCloseAfterTeleport
  3371. // flag when no teleport had taken place (and hence no close was going to come).
  3372. // if (!acd.ChildrenCapSeeds.ContainsKey(RegionInfo.RegionHandle))
  3373. // {
  3374. // m_log.DebugFormat(
  3375. // "[SCENE]: Setting DoNotCloseAfterTeleport for child scene presence {0} in {1} because source will attempt close.",
  3376. // sp.Name, Name);
  3377. //
  3378. // sp.DoNotCloseAfterTeleport = true;
  3379. // }
  3380. // else if (EntityTransferModule.IsInTransit(sp.UUID))
  3381. sp.LifecycleState = ScenePresenceState.Running;
  3382. if (EntityTransferModule.IsInTransit(sp.UUID))
  3383. {
  3384. sp.DoNotCloseAfterTeleport = true;
  3385. m_log.DebugFormat(
  3386. "[SCENE]: Set DoNotCloseAfterTeleport for child scene presence {0} in {1} because this region will attempt end-of-teleport close from a previous close.",
  3387. sp.Name, Name);
  3388. }
  3389. }
  3390. }
  3391. // Need to poll here in case we are currently deleting an sp. Letting threads run over each other will
  3392. // allow unpredictable things to happen.
  3393. if (sp != null)
  3394. {
  3395. const int polls = 10;
  3396. const int pollInterval = 1000;
  3397. int pollsLeft = polls;
  3398. while (sp.LifecycleState == ScenePresenceState.Removing && pollsLeft-- > 0)
  3399. Thread.Sleep(pollInterval);
  3400. if (sp.LifecycleState == ScenePresenceState.Removing)
  3401. {
  3402. m_log.WarnFormat(
  3403. "[SCENE]: Agent {0} in {1} was still being removed after {2}s. Aborting NewUserConnection.",
  3404. sp.Name, Name, polls * pollInterval / 1000);
  3405. return false;
  3406. }
  3407. else if (polls != pollsLeft)
  3408. {
  3409. m_log.DebugFormat(
  3410. "[SCENE]: NewUserConnection for agent {0} in {1} had to wait {2}s for in-progress removal to complete on an old presence.",
  3411. sp.Name, Name, polls * pollInterval / 1000);
  3412. }
  3413. }
  3414. // TODO: can we remove this lock?
  3415. lock (m_newUserConnLock)
  3416. {
  3417. if (sp != null && !sp.IsChildAgent)
  3418. {
  3419. // We have a root agent. Is it in transit?
  3420. if (!EntityTransferModule.IsInTransit(sp.UUID))
  3421. {
  3422. // We have a zombie from a crashed session.
  3423. // Or the same user is trying to be root twice here, won't work.
  3424. // Kill it.
  3425. m_log.WarnFormat(
  3426. "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting. Removing existing presence.",
  3427. sp.Name, sp.UUID, RegionInfo.RegionName);
  3428. if (sp.ControllingClient != null)
  3429. CloseAgent(sp.UUID, true);
  3430. sp = null;
  3431. }
  3432. //else
  3433. // m_log.WarnFormat("[SCENE]: Existing root scene presence for {0} {1} in {2}, but agent is in trasit", sp.Name, sp.UUID, RegionInfo.RegionName);
  3434. }
  3435. // Optimistic: add or update the circuit data with the new agent circuit data and teleport flags.
  3436. // We need the circuit data here for some of the subsequent checks. (groups, for example)
  3437. // If the checks fail, we remove the circuit.
  3438. acd.teleportFlags = teleportFlags;
  3439. if (vialogin)
  3440. {
  3441. IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
  3442. if (cache != null)
  3443. // cache.Remove(acd.firstname + " " + acd.lastname);
  3444. cache.Remove(acd.AgentID);
  3445. // Remove any preexisting circuit - we don't want duplicates
  3446. // This is a stab at preventing avatar "ghosting"
  3447. m_authenticateHandler.RemoveCircuit(acd.AgentID);
  3448. }
  3449. m_authenticateHandler.AddNewCircuit(acd.circuitcode, acd);
  3450. if (sp == null) // We don't have an [child] agent here already
  3451. {
  3452. if (requirePresenceLookup)
  3453. {
  3454. try
  3455. {
  3456. if (!VerifyUserPresence(acd, out reason))
  3457. {
  3458. m_authenticateHandler.RemoveCircuit(acd.circuitcode);
  3459. return false;
  3460. }
  3461. }
  3462. catch (Exception e)
  3463. {
  3464. m_log.ErrorFormat(
  3465. "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
  3466. m_authenticateHandler.RemoveCircuit(acd.circuitcode);
  3467. return false;
  3468. }
  3469. }
  3470. try
  3471. {
  3472. if (!AuthorizeUser(acd, (vialogin ? false : SeeIntoRegion), out reason))
  3473. {
  3474. m_authenticateHandler.RemoveCircuit(acd.circuitcode);
  3475. return false;
  3476. }
  3477. }
  3478. catch (Exception e)
  3479. {
  3480. m_log.ErrorFormat(
  3481. "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
  3482. m_authenticateHandler.RemoveCircuit(acd.circuitcode);
  3483. return false;
  3484. }
  3485. m_log.InfoFormat(
  3486. "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
  3487. Name, (acd.child ? "child" : "root"), acd.firstname, acd.lastname,
  3488. acd.AgentID, acd.circuitcode);
  3489. if (CapsModule != null)
  3490. {
  3491. CapsModule.SetAgentCapsSeeds(acd);
  3492. CapsModule.CreateCaps(acd.AgentID, acd.circuitcode);
  3493. }
  3494. }
  3495. else
  3496. {
  3497. // Let the SP know how we got here. This has a lot of interesting
  3498. // uses down the line.
  3499. sp.TeleportFlags = (TPFlags)teleportFlags;
  3500. if (sp.IsChildAgent)
  3501. {
  3502. m_log.DebugFormat(
  3503. "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
  3504. acd.AgentID, RegionInfo.RegionName);
  3505. if (CapsModule != null)
  3506. {
  3507. CapsModule.SetAgentCapsSeeds(acd);
  3508. CapsModule.CreateCaps(acd.AgentID, acd.circuitcode);
  3509. }
  3510. sp.AdjustKnownSeeds();
  3511. }
  3512. }
  3513. // Try caching an incoming user name much earlier on to see if this helps with an issue
  3514. // where HG users are occasionally seen by others as "Unknown User" because their UUIDName
  3515. // request for the HG avatar appears to trigger before the user name is cached.
  3516. CacheUserName(null, acd);
  3517. }
  3518. if (CapsModule != null)
  3519. {
  3520. CapsModule.ActivateCaps(acd.circuitcode);
  3521. }
  3522. // if (vialogin)
  3523. // {
  3524. // CleanDroppedAttachments();
  3525. // }
  3526. if(teleportFlags != (uint) TPFlags.Default)
  3527. {
  3528. // Make sure root avatar position is in the region
  3529. if (acd.startpos.X < 0)
  3530. acd.startpos.X = 1f;
  3531. else if (acd.startpos.X >= RegionInfo.RegionSizeX)
  3532. acd.startpos.X = RegionInfo.RegionSizeX - 1f;
  3533. if (acd.startpos.Y < 0)
  3534. acd.startpos.Y = 1f;
  3535. else if (acd.startpos.Y >= RegionInfo.RegionSizeY)
  3536. acd.startpos.Y = RegionInfo.RegionSizeY - 1f;
  3537. }
  3538. // only check access, actual relocations will happen later on ScenePresence MakeRoot
  3539. // allow child agents creation
  3540. // if(!godlike && teleportFlags != (uint) TPFlags.Default)
  3541. if(teleportFlags != (uint) TPFlags.Default)
  3542. {
  3543. bool checkTeleHub;
  3544. // don't check hubs if via home or via lure
  3545. if((teleportFlags & (uint) TPFlags.ViaHome) != 0
  3546. || (teleportFlags & (uint) TPFlags.ViaLure) != 0)
  3547. checkTeleHub = false;
  3548. else
  3549. checkTeleHub = vialogin
  3550. || (TelehubAllowLandmarks == true ? false : ((teleportFlags & (uint)TPFlags.ViaLandmark) != 0 ))
  3551. || (teleportFlags & (uint) TPFlags.ViaLocation) != 0;
  3552. if(!CheckLandPositionAccess(acd.AgentID, true, checkTeleHub, acd.startpos, out reason))
  3553. {
  3554. m_authenticateHandler.RemoveCircuit(acd.circuitcode);
  3555. return false;
  3556. }
  3557. }
  3558. return true;
  3559. }
  3560. private bool IsPositionAllowed(UUID agentID, Vector3 pos, ref string reason)
  3561. {
  3562. ILandObject land = LandChannel.GetLandObject(pos);
  3563. if (land == null)
  3564. return true;
  3565. if (land.IsBannedFromLand(agentID) || land.IsRestrictedFromLand(agentID))
  3566. {
  3567. reason = "You are banned from the region.";
  3568. return false;
  3569. }
  3570. return true;
  3571. }
  3572. public bool TestLandRestrictions(UUID agentID, out string reason, ref float posX, ref float posY)
  3573. {
  3574. if (posX < 0)
  3575. posX = 0;
  3576. else if (posX >= RegionInfo.RegionSizeX)
  3577. posX = RegionInfo.RegionSizeX - 0.5f;
  3578. if (posY < 0)
  3579. posY = 0;
  3580. else if (posY >= RegionInfo.RegionSizeY)
  3581. posY = RegionInfo.RegionSizeY - 0.5f;
  3582. reason = String.Empty;
  3583. if (Permissions.IsGod(agentID))
  3584. return true;
  3585. ILandObject land = LandChannel.GetLandObject(posX, posY);
  3586. if (land == null)
  3587. return false;
  3588. bool banned = land.IsBannedFromLand(agentID);
  3589. bool restricted = land.IsRestrictedFromLand(agentID);
  3590. if (banned || restricted)
  3591. {
  3592. ILandObject nearestParcel = GetNearestAllowedParcel(agentID, posX, posY);
  3593. Vector2? newPosition = null;
  3594. if (nearestParcel != null)
  3595. {
  3596. //Move agent to nearest allowed
  3597. // Vector2 newPosition = GetParcelSafeCorner(nearestParcel);
  3598. newPosition = nearestParcel.GetNearestPoint(new Vector3(posX, posY,0));
  3599. }
  3600. if(newPosition == null)
  3601. {
  3602. if (banned)
  3603. {
  3604. reason = "Cannot regioncross into banned parcel.";
  3605. }
  3606. else
  3607. {
  3608. reason = String.Format("Denied access to private region {0}: You are not on the access list for that region.",
  3609. RegionInfo.RegionName);
  3610. }
  3611. return false;
  3612. }
  3613. else
  3614. {
  3615. posX = newPosition.Value.X;
  3616. posY = newPosition.Value.Y;
  3617. }
  3618. }
  3619. reason = "";
  3620. return true;
  3621. }
  3622. /// <summary>
  3623. /// Verifies that the user has a presence on the Grid
  3624. /// </summary>
  3625. /// <param name="agent">Circuit Data of the Agent we're verifying</param>
  3626. /// <param name="reason">Outputs the reason for the false response on this string</param>
  3627. /// <returns>True if the user has a session on the grid. False if it does not. False will
  3628. /// also return a reason.</returns>
  3629. public virtual bool VerifyUserPresence(AgentCircuitData agent, out string reason)
  3630. {
  3631. reason = String.Empty;
  3632. IPresenceService presence = RequestModuleInterface<IPresenceService>();
  3633. if (presence == null)
  3634. {
  3635. reason = String.Format("Failed to verify user presence in the grid for {0} {1} in region {2}. Presence service does not exist.", agent.firstname, agent.lastname, RegionInfo.RegionName);
  3636. return false;
  3637. }
  3638. OpenSim.Services.Interfaces.PresenceInfo pinfo = presence.GetAgent(agent.SessionID);
  3639. if (pinfo == null)
  3640. {
  3641. reason = String.Format("Failed to verify user presence in the grid for {0} {1}, access denied to region {2}.", agent.firstname, agent.lastname, RegionInfo.RegionName);
  3642. return false;
  3643. }
  3644. return true;
  3645. }
  3646. /// <summary>
  3647. /// Verify if the user can connect to this region. Checks the banlist and ensures that the region is set for public access
  3648. /// </summary>
  3649. /// <param name="agent">The circuit data for the agent</param>
  3650. /// <param name="reason">outputs the reason to this string</param>
  3651. /// <returns>True if the region accepts this agent. False if it does not. False will
  3652. /// also return a reason.</returns>
  3653. protected virtual bool AuthorizeUser(AgentCircuitData agent, bool bypassAccessControl, out string reason)
  3654. {
  3655. reason = String.Empty;
  3656. if (!m_strictAccessControl)
  3657. return true;
  3658. if (Permissions.IsGod(agent.AgentID))
  3659. return true;
  3660. if (AuthorizationService != null)
  3661. {
  3662. if (!AuthorizationService.IsAuthorizedForRegion(
  3663. agent.AgentID.ToString(), agent.firstname, agent.lastname, RegionInfo.RegionID.ToString(), out reason))
  3664. {
  3665. m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because: {4}",
  3666. agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName, reason);
  3667. return false;
  3668. }
  3669. }
  3670. // We only test the things below when we want to cut off
  3671. // child agents from being present in the scene for which their root
  3672. // agent isn't allowed. Otherwise, we allow child agents. The test for
  3673. // the root is done elsewhere (QueryAccess)
  3674. if (!bypassAccessControl)
  3675. {
  3676. if(RegionInfo.EstateSettings == null)
  3677. {
  3678. // something is broken? let it get in
  3679. m_log.ErrorFormat("[CONNECTION BEGIN]: Estate Settings is null!");
  3680. return true;
  3681. }
  3682. // check estate ban
  3683. int flags = GetUserFlags(agent.AgentID);
  3684. if (RegionInfo.EstateSettings.IsBanned(agent.AgentID, flags))
  3685. {
  3686. m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user is on the banlist",
  3687. agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
  3688. reason = String.Format("Denied access to region {0}: You have been banned from that region.",
  3689. RegionInfo.RegionName);
  3690. return false;
  3691. }
  3692. // public access
  3693. if (RegionInfo.EstateSettings.PublicAccess)
  3694. return true;
  3695. // in access list / owner / manager
  3696. if (RegionInfo.EstateSettings.HasAccess(agent.AgentID))
  3697. return true;
  3698. // finally test groups
  3699. bool groupAccess = false;
  3700. // some say GOTO is ugly
  3701. if(m_groupsModule == null) // if no groups refuse
  3702. goto Label_GroupsDone;
  3703. UUID[] estateGroups = RegionInfo.EstateSettings.EstateGroups;
  3704. if(estateGroups == null)
  3705. {
  3706. m_log.ErrorFormat("[CONNECTION BEGIN]: Estate GroupMembership is null!");
  3707. goto Label_GroupsDone;
  3708. }
  3709. if(estateGroups.Length == 0)
  3710. goto Label_GroupsDone;
  3711. List<UUID> agentGroups = new List<UUID>();
  3712. GroupMembershipData[] GroupMembership = m_groupsModule.GetMembershipData(agent.AgentID);
  3713. if(GroupMembership == null)
  3714. {
  3715. m_log.ErrorFormat("[CONNECTION BEGIN]: GroupMembership is null!");
  3716. goto Label_GroupsDone;
  3717. }
  3718. if(GroupMembership.Length == 0)
  3719. goto Label_GroupsDone;
  3720. for(int i = 0;i < GroupMembership.Length;i++)
  3721. agentGroups.Add(GroupMembership[i].GroupID);
  3722. foreach(UUID group in estateGroups)
  3723. {
  3724. if(agentGroups.Contains(group))
  3725. {
  3726. groupAccess = true;
  3727. break;
  3728. }
  3729. }
  3730. Label_GroupsDone:
  3731. if (!groupAccess)
  3732. {
  3733. m_log.WarnFormat("[CONNECTION BEGIN]: Denied access to: {0} ({1} {2}) at {3} because the user does not have access to the estate",
  3734. agent.AgentID, agent.firstname, agent.lastname, RegionInfo.RegionName);
  3735. reason = String.Format("Denied access to private region {0}: You do not have access to that region.",
  3736. RegionInfo.RegionName);
  3737. return false;
  3738. }
  3739. }
  3740. return true;
  3741. }
  3742. /// <summary>
  3743. /// Update an AgentCircuitData object with new information
  3744. /// </summary>
  3745. /// <param name="data">Information to update the AgentCircuitData with</param>
  3746. public void UpdateCircuitData(AgentCircuitData data)
  3747. {
  3748. m_authenticateHandler.UpdateAgentData(data);
  3749. }
  3750. /// <summary>
  3751. /// Change the Circuit Code for the user's Circuit Data
  3752. /// </summary>
  3753. /// <param name="oldcc">The old Circuit Code. Must match a previous circuit code</param>
  3754. /// <param name="newcc">The new Circuit Code. Must not be an already existing circuit code</param>
  3755. /// <returns>True if we successfully changed it. False if we did not</returns>
  3756. public bool ChangeCircuitCode(uint oldcc, uint newcc)
  3757. {
  3758. return m_authenticateHandler.TryChangeCiruitCode(oldcc, newcc);
  3759. }
  3760. // /// <summary>
  3761. // /// The Grid has requested that we log-off a user. Log them off.
  3762. // /// </summary>
  3763. // /// <param name="AvatarID">Unique ID of the avatar to log-off</param>
  3764. // /// <param name="RegionSecret">SecureSessionID of the user, or the RegionSecret text when logging on to the grid</param>
  3765. // /// <param name="message">message to display to the user. Reason for being logged off</param>
  3766. // public void HandleLogOffUserFromGrid(UUID AvatarID, UUID RegionSecret, string message)
  3767. // {
  3768. // ScenePresence loggingOffUser = GetScenePresence(AvatarID);
  3769. // if (loggingOffUser != null)
  3770. // {
  3771. // UUID localRegionSecret = UUID.Zero;
  3772. // bool parsedsecret = UUID.TryParse(RegionInfo.regionSecret, out localRegionSecret);
  3773. //
  3774. // // Region Secret is used here in case a new sessionid overwrites an old one on the user server.
  3775. // // Will update the user server in a few revisions to use it.
  3776. //
  3777. // if (RegionSecret == loggingOffUser.ControllingClient.SecureSessionId || (parsedsecret && RegionSecret == localRegionSecret))
  3778. // {
  3779. // m_sceneGridService.SendCloseChildAgentConnections(loggingOffUser.UUID, loggingOffUser.KnownRegionHandles);
  3780. // loggingOffUser.ControllingClient.Kick(message);
  3781. // // Give them a second to receive the message!
  3782. // Thread.Sleep(1000);
  3783. // loggingOffUser.ControllingClient.Close();
  3784. // }
  3785. // else
  3786. // {
  3787. // m_log.Info("[USERLOGOFF]: System sending the LogOff user message failed to sucessfully authenticate");
  3788. // }
  3789. // }
  3790. // else
  3791. // {
  3792. // m_log.InfoFormat("[USERLOGOFF]: Got a logoff request for {0} but the user isn't here. The user might already have been logged out", AvatarID.ToString());
  3793. // }
  3794. // }
  3795. // /// <summary>
  3796. // /// Triggered when an agent crosses into this sim. Also happens on initial login.
  3797. // /// </summary>
  3798. // /// <param name="agentID"></param>
  3799. // /// <param name="position"></param>
  3800. // /// <param name="isFlying"></param>
  3801. // public virtual void AgentCrossing(UUID agentID, Vector3 position, bool isFlying)
  3802. // {
  3803. // ScenePresence presence = GetScenePresence(agentID);
  3804. // if (presence != null)
  3805. // {
  3806. // try
  3807. // {
  3808. // presence.MakeRootAgent(position, isFlying);
  3809. // }
  3810. // catch (Exception e)
  3811. // {
  3812. // m_log.ErrorFormat("[SCENE]: Unable to do agent crossing, exception {0}{1}", e.Message, e.StackTrace);
  3813. // }
  3814. // }
  3815. // else
  3816. // {
  3817. // m_log.ErrorFormat(
  3818. // "[SCENE]: Could not find presence for agent {0} crossing into scene {1}",
  3819. // agentID, RegionInfo.RegionName);
  3820. // }
  3821. // }
  3822. /// <summary>
  3823. /// We've got an update about an agent that sees into this region,
  3824. /// send it to ScenePresence for processing It's the full data.
  3825. /// </summary>
  3826. /// <param name="cAgentData">Agent that contains all of the relevant things about an agent.
  3827. /// Appearance, animations, position, etc.</param>
  3828. /// <returns>true if we handled it.</returns>
  3829. public virtual bool IncomingUpdateChildAgent(AgentData cAgentData)
  3830. {
  3831. m_log.DebugFormat(
  3832. "[SCENE]: Incoming child agent update for {0} in {1}", cAgentData.AgentID, RegionInfo.RegionName);
  3833. if (!LoginsEnabled)
  3834. {
  3835. // reason = "Logins Disabled";
  3836. m_log.DebugFormat(
  3837. "[SCENE]: update for {0} in {1} refused: Logins Disabled", cAgentData.AgentID, RegionInfo.RegionName);
  3838. return false;
  3839. }
  3840. int flags = GetUserFlags(cAgentData.AgentID);
  3841. if (RegionInfo.EstateSettings.IsBanned(cAgentData.AgentID, flags))
  3842. {
  3843. m_log.DebugFormat("[SCENE]: Denying root agent entry to {0}: banned", cAgentData.AgentID);
  3844. return false;
  3845. }
  3846. // TODO: This check should probably be in QueryAccess().
  3847. ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID,
  3848. (float)RegionInfo.RegionSizeX * 0.5f, (float)RegionInfo.RegionSizeY * 0.5f);
  3849. if (nearestParcel == null)
  3850. {
  3851. m_log.InfoFormat(
  3852. "[SCENE]: Denying root agent entry to {0} in {1}: no allowed parcel",
  3853. cAgentData.AgentID, RegionInfo.RegionName);
  3854. return false;
  3855. }
  3856. // We have to wait until the viewer contacts this region
  3857. // after receiving the EnableSimulator HTTP Event Queue message (for the v1 teleport protocol)
  3858. // or TeleportFinish (for the v2 teleport protocol). This triggers the viewer to send
  3859. // a UseCircuitCode packet which in turn calls AddNewAgent which finally creates the ScenePresence.
  3860. ScenePresence sp = WaitGetScenePresence(cAgentData.AgentID);
  3861. if (sp != null)
  3862. {
  3863. if (!sp.IsChildAgent)
  3864. {
  3865. m_log.WarnFormat("[SCENE]: Ignoring a child update on a root agent {0} {1} in {2}",
  3866. sp.Name, sp.UUID, Name);
  3867. return false;
  3868. }
  3869. if (cAgentData.SessionID != sp.ControllingClient.SessionId)
  3870. {
  3871. m_log.WarnFormat(
  3872. "[SCENE]: Attempt to update agent {0} with diferent session id {1} != {2}",
  3873. sp.UUID, sp.ControllingClient.SessionId, cAgentData.SessionID);
  3874. return false;
  3875. }
  3876. sp.UpdateChildAgent(cAgentData);
  3877. int ntimes = 100;
  3878. if (cAgentData.SenderWantsToWaitForRoot)
  3879. {
  3880. while (sp.IsChildAgent && ntimes-- > 0)
  3881. Thread.Sleep(250);
  3882. if (sp.IsChildAgent)
  3883. {
  3884. m_log.WarnFormat(
  3885. "[SCENE]: Found presence {0} {1} unexpectedly still child in {2}",
  3886. sp.Name, sp.UUID, Name);
  3887. return false;
  3888. }
  3889. }
  3890. return true;
  3891. }
  3892. return false;
  3893. }
  3894. /// <summary>
  3895. /// We've got an update about an agent that sees into this region,
  3896. /// send it to ScenePresence for processing It's only positional data
  3897. /// </summary>
  3898. /// <param name="cAgentData">AgentPosition that contains agent positional data so we can know what to send</param>
  3899. /// <returns>true if we handled it.</returns>
  3900. public virtual bool IncomingUpdateChildAgent(AgentPosition cAgentData)
  3901. {
  3902. // m_log.DebugFormat(
  3903. // "[SCENE PRESENCE]: IncomingChildAgentDataUpdate POSITION for {0} in {1}, position {2}",
  3904. // cAgentData.AgentID, Name, cAgentData.Position);
  3905. ScenePresence childAgentUpdate = GetScenePresence(cAgentData.AgentID);
  3906. if (childAgentUpdate != null)
  3907. {
  3908. // if (childAgentUpdate.ControllingClient.SessionId != cAgentData.SessionID)
  3909. // // Only warn for now
  3910. // m_log.WarnFormat("[SCENE]: Attempt at updating position of agent {0} with invalid session id {1}. Neighbor running older version?",
  3911. // childAgentUpdate.UUID, cAgentData.SessionID);
  3912. // I can't imagine *yet* why we would get an update if the agent is a root agent..
  3913. // however to avoid a race condition crossing borders..
  3914. if (childAgentUpdate.IsChildAgent)
  3915. {
  3916. uint rRegionX = (uint)(cAgentData.RegionHandle >> 40);
  3917. uint rRegionY = (((uint)(cAgentData.RegionHandle)) >> 8);
  3918. uint tRegionX = RegionInfo.RegionLocX;
  3919. uint tRegionY = RegionInfo.RegionLocY;
  3920. //Send Data to ScenePresence
  3921. childAgentUpdate.UpdateChildAgent(cAgentData, tRegionX, tRegionY, rRegionX, rRegionY);
  3922. // Not Implemented:
  3923. //TODO: Do we need to pass the message on to one of our neighbors?
  3924. }
  3925. return true;
  3926. }
  3927. return false;
  3928. }
  3929. /// <summary>
  3930. /// Poll until the requested ScenePresence appears or we timeout.
  3931. /// </summary>
  3932. /// <returns>The scene presence is found, else null.</returns>
  3933. /// <param name='agentID'></param>
  3934. protected virtual ScenePresence WaitGetScenePresence(UUID agentID)
  3935. {
  3936. int ntimes = 120; // 30s
  3937. ScenePresence sp = null;
  3938. while ((sp = GetScenePresence(agentID)) == null && (ntimes-- > 0))
  3939. Thread.Sleep(250);
  3940. if (sp == null)
  3941. m_log.WarnFormat(
  3942. "[SCENE PRESENCE]: Did not find presence with id {0} in {1} before timeout",
  3943. agentID, RegionInfo.RegionName);
  3944. return sp;
  3945. }
  3946. /// <summary>
  3947. /// Authenticated close (via network)
  3948. /// </summary>
  3949. /// <param name="agentID"></param>
  3950. /// <param name="force"></param>
  3951. /// <param name="auth_token"></param>
  3952. /// <returns></returns>
  3953. public bool CloseAgent(UUID agentID, bool force, string auth_token)
  3954. {
  3955. //m_log.DebugFormat("[SCENE]: Processing incoming close agent {0} in region {1} with auth_token {2}", agentID, RegionInfo.RegionName, auth_token);
  3956. // Check that the auth_token is valid
  3957. AgentCircuitData acd = AuthenticateHandler.GetAgentCircuitData(agentID);
  3958. if (acd == null)
  3959. {
  3960. m_log.DebugFormat(
  3961. "[SCENE]: Request to close agent {0} but no such agent in scene {1}. May have been closed previously.",
  3962. agentID, Name);
  3963. return false;
  3964. }
  3965. if (acd.SessionID.ToString() == auth_token)
  3966. {
  3967. return CloseAgent(agentID, force);
  3968. }
  3969. else
  3970. {
  3971. m_log.WarnFormat(
  3972. "[SCENE]: Request to close agent {0} with invalid authorization token {1} in {2}",
  3973. agentID, auth_token, Name);
  3974. }
  3975. return false;
  3976. }
  3977. /// <summary>
  3978. /// Tell a single client to prepare to close.
  3979. /// </summary>
  3980. /// <remarks>
  3981. /// This should only be called if we may close the client but there will be some delay in so doing. Meant for
  3982. /// internal use - other callers should almost certainly called CloseClient().
  3983. /// </remarks>
  3984. /// <param name="sp"></param>
  3985. /// <returns>true if pre-close state notification was successful. false if the agent
  3986. /// was not in a state where it could transition to pre-close.</returns>
  3987. public bool IncomingPreCloseClient(ScenePresence sp)
  3988. {
  3989. lock (m_removeClientLock)
  3990. {
  3991. // We need to avoid a race condition where in, for example, an A B C D region layout, an avatar may
  3992. // teleport from A -> D, but then -> C before A has asked B to close its old child agent. We do not
  3993. // want to obey this close since C may have renewed the child agent lease on B.
  3994. if (sp.DoNotCloseAfterTeleport)
  3995. {
  3996. m_log.DebugFormat(
  3997. "[SCENE]: Not pre-closing {0} agent {1} in {2} since another simulator has re-established the child connection",
  3998. sp.IsChildAgent ? "child" : "root", sp.Name, Name);
  3999. // Need to reset the flag so that a subsequent close after another teleport can succeed.
  4000. sp.DoNotCloseAfterTeleport = false;
  4001. return false;
  4002. }
  4003. if (sp.LifecycleState != ScenePresenceState.Running)
  4004. {
  4005. m_log.DebugFormat(
  4006. "[SCENE]: Called IncomingPreCloseAgent() for {0} in {1} but presence is already in state {2}",
  4007. sp.Name, Name, sp.LifecycleState);
  4008. return false;
  4009. }
  4010. sp.LifecycleState = ScenePresenceState.PreRemove;
  4011. return true;
  4012. }
  4013. }
  4014. /// <summary>
  4015. /// Tell a single agent to disconnect from the region.
  4016. /// </summary>
  4017. /// <param name="agentID"></param>
  4018. /// <param name="force">
  4019. /// Force the agent to close even if it might be in the middle of some other operation. You do not want to
  4020. /// force unless you are absolutely sure that the agent is dead and a normal close is not working.
  4021. /// </param>
  4022. public override bool CloseAgent(UUID agentID, bool force)
  4023. {
  4024. ScenePresence sp;
  4025. lock (m_removeClientLock)
  4026. {
  4027. sp = GetScenePresence(agentID);
  4028. if (sp == null)
  4029. {
  4030. // If there is no scene presence, we may be handling a dead
  4031. // client. These can keep an avatar from reentering a region
  4032. // and since they don't get cleaned up they will stick
  4033. // around until region restart. So, if there is no SP,
  4034. // remove the client as well.
  4035. IClientAPI client = null;
  4036. if (m_clientManager.TryGetValue(agentID, out client))
  4037. {
  4038. m_clientManager.Remove(agentID);
  4039. if (CapsModule != null)
  4040. CapsModule.RemoveCaps(agentID, 0);
  4041. m_log.DebugFormat( "[SCENE]: Dead client for agent ID {0} was cleaned up in {1}", agentID, Name);
  4042. return true;
  4043. }
  4044. m_log.DebugFormat(
  4045. "[SCENE]: Called CloseClient() with agent ID {0} but no such presence is in {1}",
  4046. agentID, Name);
  4047. return false;
  4048. }
  4049. if (sp.LifecycleState != ScenePresenceState.Running && sp.LifecycleState != ScenePresenceState.PreRemove)
  4050. {
  4051. m_log.DebugFormat(
  4052. "[SCENE]: Called CloseClient() for {0} in {1} but presence is already in state {2}",
  4053. sp.Name, Name, sp.LifecycleState);
  4054. return false;
  4055. }
  4056. // We need to avoid a race condition where in, for example, an A B C D region layout, an avatar may
  4057. // teleport from A -> D, but then -> C before A has asked B to close its old child agent. We do not
  4058. // want to obey this close since C may have renewed the child agent lease on B.
  4059. if (sp.DoNotCloseAfterTeleport)
  4060. {
  4061. m_log.DebugFormat(
  4062. "[SCENE]: Not closing {0} agent {1} in {2} since another simulator has re-established the child connection",
  4063. sp.IsChildAgent ? "child" : "root", sp.Name, Name);
  4064. // Need to reset the flag so that a subsequent close after another teleport can succeed.
  4065. sp.DoNotCloseAfterTeleport = false;
  4066. return false;
  4067. }
  4068. sp.LifecycleState = ScenePresenceState.Removing;
  4069. }
  4070. if (sp != null)
  4071. {
  4072. sp.ControllingClient.Close(force, force);
  4073. if(sp.IsNPC && UserManagementModule != null)
  4074. UserManagementModule.RemoveUser(sp.UUID);
  4075. return true;
  4076. }
  4077. return true;
  4078. }
  4079. /// <summary>
  4080. /// Tries to teleport agent to another region.
  4081. /// </summary>
  4082. /// <remarks>
  4083. /// The region name must exactly match that given.
  4084. /// </remarks>
  4085. /// <param name="remoteClient"></param>
  4086. /// <param name="regionName"></param>
  4087. /// <param name="position"></param>
  4088. /// <param name="lookAt"></param>
  4089. /// <param name="teleportFlags"></param>
  4090. public void RequestTeleportLocation(IClientAPI remoteClient, string regionName, Vector3 position,
  4091. Vector3 lookat, uint teleportFlags)
  4092. {
  4093. if (EntityTransferModule == null)
  4094. {
  4095. m_log.DebugFormat("[SCENE]: Unable to perform teleports: no AgentTransferModule is active");
  4096. return;
  4097. }
  4098. ScenePresence sp = GetScenePresence(remoteClient.AgentId);
  4099. if (sp == null || sp.IsDeleted || sp.IsInTransit)
  4100. return;
  4101. ulong regionHandle = 0;
  4102. if(regionName == RegionInfo.RegionName)
  4103. regionHandle = RegionInfo.RegionHandle;
  4104. else
  4105. {
  4106. GridRegion region = GridService.GetRegionByName(RegionInfo.ScopeID, regionName);
  4107. if (region != null)
  4108. regionHandle = region.RegionHandle;
  4109. }
  4110. if(regionHandle == 0)
  4111. {
  4112. // can't find the region: Tell viewer and abort
  4113. remoteClient.SendTeleportFailed("The region '" + regionName + "' could not be found.");
  4114. return;
  4115. }
  4116. EntityTransferModule.Teleport(sp, regionHandle, position, lookat, teleportFlags);
  4117. }
  4118. /// <summary>
  4119. /// Tries to teleport agent to other region.
  4120. /// </summary>
  4121. /// <param name="remoteClient"></param>
  4122. /// <param name="regionHandle"></param>
  4123. /// <param name="position"></param>
  4124. /// <param name="lookAt"></param>
  4125. /// <param name="teleportFlags"></param>
  4126. public void RequestTeleportLocation(IClientAPI remoteClient, ulong regionHandle, Vector3 position,
  4127. Vector3 lookAt, uint teleportFlags)
  4128. {
  4129. if (EntityTransferModule == null)
  4130. {
  4131. m_log.DebugFormat("[SCENE]: Unable to perform teleports: no AgentTransferModule is active");
  4132. return;
  4133. }
  4134. ScenePresence sp = GetScenePresence(remoteClient.AgentId);
  4135. if (sp == null || sp.IsDeleted || sp.IsInTransit)
  4136. return;
  4137. EntityTransferModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
  4138. }
  4139. public bool CrossAgentToNewRegion(ScenePresence agent, bool isFlying)
  4140. {
  4141. if (EntityTransferModule != null)
  4142. {
  4143. return EntityTransferModule.Cross(agent, isFlying);
  4144. }
  4145. else
  4146. {
  4147. m_log.DebugFormat("[SCENE]: Unable to cross agent to neighbouring region, because there is no AgentTransferModule");
  4148. }
  4149. return false;
  4150. }
  4151. public void SendOutChildAgentUpdates(AgentPosition cadu, ScenePresence presence)
  4152. {
  4153. m_sceneGridService.SendChildAgentDataUpdate(cadu, presence);
  4154. }
  4155. #endregion
  4156. #region Other Methods
  4157. protected override IConfigSource GetConfig()
  4158. {
  4159. return m_config;
  4160. }
  4161. #endregion
  4162. public void HandleObjectPermissionsUpdate(IClientAPI controller, UUID agentID, UUID sessionID, byte field, uint localId, uint mask, byte set)
  4163. {
  4164. // Check for spoofing.. since this is permissions we're talking about here!
  4165. if ((controller.SessionId == sessionID) && (controller.AgentId == agentID))
  4166. {
  4167. // Tell the object to do permission update
  4168. if (localId != 0)
  4169. {
  4170. SceneObjectGroup chObjectGroup = GetGroupByPrim(localId);
  4171. if (chObjectGroup != null)
  4172. {
  4173. chObjectGroup.UpdatePermissions(agentID, field, localId, mask, set);
  4174. }
  4175. }
  4176. }
  4177. }
  4178. /// <summary>
  4179. /// Causes all clients to get a full object update on all of the objects in the scene.
  4180. /// </summary>
  4181. public void ForceClientUpdate()
  4182. {
  4183. EntityBase[] entityList = GetEntities();
  4184. foreach (EntityBase ent in entityList)
  4185. {
  4186. if (ent is SceneObjectGroup)
  4187. {
  4188. ((SceneObjectGroup)ent).ScheduleGroupForFullUpdate();
  4189. }
  4190. }
  4191. }
  4192. /// <summary>
  4193. /// This is currently only used for scale (to scale to MegaPrim size)
  4194. /// There is a console command that calls this in OpenSimMain
  4195. /// </summary>
  4196. /// <param name="cmdparams"></param>
  4197. public void HandleEditCommand(string[] cmdparams)
  4198. {
  4199. m_log.DebugFormat("Searching for Primitive: '{0}'", cmdparams[2]);
  4200. EntityBase[] entityList = GetEntities();
  4201. foreach (EntityBase ent in entityList)
  4202. {
  4203. if (ent is SceneObjectGroup)
  4204. {
  4205. SceneObjectPart part = ((SceneObjectGroup)ent).GetPart(((SceneObjectGroup)ent).UUID);
  4206. if (part != null)
  4207. {
  4208. if (part.Name == cmdparams[2])
  4209. {
  4210. part.Resize(
  4211. new Vector3(Convert.ToSingle(cmdparams[3]), Convert.ToSingle(cmdparams[4]),
  4212. Convert.ToSingle(cmdparams[5])));
  4213. m_log.DebugFormat("Edited scale of Primitive: {0}", part.Name);
  4214. }
  4215. }
  4216. }
  4217. }
  4218. }
  4219. #region Script Handling Methods
  4220. /// <summary>
  4221. /// Console command handler to send script command to script engine.
  4222. /// </summary>
  4223. /// <param name="args"></param>
  4224. public void SendCommandToPlugins(string[] args)
  4225. {
  4226. m_eventManager.TriggerOnPluginConsole(args);
  4227. }
  4228. public LandData GetLandData(float x, float y)
  4229. {
  4230. ILandObject parcel = LandChannel.GetLandObject(x, y);
  4231. if (parcel == null)
  4232. return null;
  4233. return parcel.LandData;
  4234. }
  4235. /// <summary>
  4236. /// Get LandData by position.
  4237. /// </summary>
  4238. /// <param name="pos"></param>
  4239. /// <returns></returns>
  4240. public LandData GetLandData(Vector3 pos)
  4241. {
  4242. return GetLandData(pos.X, pos.Y);
  4243. }
  4244. public LandData GetLandData(uint x, uint y)
  4245. {
  4246. // m_log.DebugFormat("[SCENE]: returning land for {0},{1}", x, y);
  4247. ILandObject parcel = LandChannel.GetLandObject((int)x, (int)y);
  4248. if (parcel == null)
  4249. return null;
  4250. return parcel.LandData;
  4251. }
  4252. #endregion
  4253. #region Script Engine
  4254. public bool LSLScriptDanger(SceneObjectPart part, Vector3 pos)
  4255. {
  4256. ILandObject parcel = LandChannel.GetLandObject(pos.X, pos.Y);
  4257. if (parcel == null)
  4258. return true;
  4259. LandData ldata = parcel.LandData;
  4260. if (ldata == null)
  4261. return true;
  4262. uint landflags = ldata.Flags;
  4263. uint mask = (uint)(ParcelFlags.CreateObjects | ParcelFlags.AllowAPrimitiveEntry);
  4264. if((landflags & mask) != mask)
  4265. return true;
  4266. if((landflags & (uint)ParcelFlags.AllowOtherScripts) != 0)
  4267. return false;
  4268. if(part == null)
  4269. return true;
  4270. if(part.GroupID == ldata.GroupID && (landflags & (uint)ParcelFlags.AllowGroupScripts) != 0)
  4271. return false;
  4272. return true;
  4273. }
  4274. private bool ScriptDanger(SceneObjectPart part, Vector3 pos)
  4275. {
  4276. if (part == null)
  4277. return false;
  4278. ILandObject parcel = LandChannel.GetLandObject(pos.X, pos.Y);
  4279. if (parcel != null)
  4280. {
  4281. if ((parcel.LandData.Flags & (uint)ParcelFlags.AllowOtherScripts) != 0)
  4282. return true;
  4283. if ((part.OwnerID == parcel.LandData.OwnerID) || Permissions.IsGod(part.OwnerID))
  4284. return true;
  4285. if (((parcel.LandData.Flags & (uint)ParcelFlags.AllowGroupScripts) != 0)
  4286. && (parcel.LandData.GroupID != UUID.Zero) && (parcel.LandData.GroupID == part.GroupID))
  4287. return true;
  4288. }
  4289. else
  4290. {
  4291. if (pos.X > 0f && pos.X < RegionInfo.RegionSizeX && pos.Y > 0f && pos.Y < RegionInfo.RegionSizeY)
  4292. return true;
  4293. }
  4294. return false;
  4295. }
  4296. public bool PipeEventsForScript(uint localID)
  4297. {
  4298. SceneObjectPart part = GetSceneObjectPart(localID);
  4299. if (part != null)
  4300. {
  4301. SceneObjectPart parent = part.ParentGroup.RootPart;
  4302. return ScriptDanger(parent, parent.GetWorldPosition());
  4303. }
  4304. else
  4305. {
  4306. return false;
  4307. }
  4308. }
  4309. #endregion
  4310. #region SceneGraph wrapper methods
  4311. public void SwapRootAgentCount(bool rootChildChildRootTF)
  4312. {
  4313. m_sceneGraph.SwapRootChildAgent(rootChildChildRootTF);
  4314. }
  4315. public void AddPhysicalPrim(int num)
  4316. {
  4317. m_sceneGraph.AddPhysicalPrim(num);
  4318. }
  4319. public void RemovePhysicalPrim(int num)
  4320. {
  4321. m_sceneGraph.RemovePhysicalPrim(num);
  4322. }
  4323. public int GetRootAgentCount()
  4324. {
  4325. return m_sceneGraph.GetRootAgentCount();
  4326. }
  4327. public int GetChildAgentCount()
  4328. {
  4329. return m_sceneGraph.GetChildAgentCount();
  4330. }
  4331. /// <summary>
  4332. /// Request a scene presence by UUID. Fast, indexed lookup.
  4333. /// </summary>
  4334. /// <param name="agentID"></param>
  4335. /// <returns>null if the presence was not found</returns>
  4336. public ScenePresence GetScenePresence(UUID agentID)
  4337. {
  4338. return m_sceneGraph.GetScenePresence(agentID);
  4339. }
  4340. /// <summary>
  4341. /// Request the scene presence by name.
  4342. /// </summary>
  4343. /// <param name="firstName"></param>
  4344. /// <param name="lastName"></param>
  4345. /// <returns>null if the presence was not found</returns>
  4346. public ScenePresence GetScenePresence(string firstName, string lastName)
  4347. {
  4348. return m_sceneGraph.GetScenePresence(firstName, lastName);
  4349. }
  4350. /// <summary>
  4351. /// Request the scene presence by localID.
  4352. /// </summary>
  4353. /// <param name="localID"></param>
  4354. /// <returns>null if the presence was not found</returns>
  4355. public ScenePresence GetScenePresence(uint localID)
  4356. {
  4357. return m_sceneGraph.GetScenePresence(localID);
  4358. }
  4359. /// <summary>
  4360. /// Gets all the scene presences in this scene.
  4361. /// </summary>
  4362. /// <remarks>
  4363. /// This method will return both root and child scene presences.
  4364. ///
  4365. /// Consider using ForEachScenePresence() or ForEachRootScenePresence() if possible since these will not
  4366. /// involving creating a new List object.
  4367. /// </remarks>
  4368. /// <returns>
  4369. /// A list of the scene presences. Adding or removing from the list will not affect the presences in the scene.
  4370. /// </returns>
  4371. public List<ScenePresence> GetScenePresences()
  4372. {
  4373. return new List<ScenePresence>(m_sceneGraph.GetScenePresences());
  4374. }
  4375. /// <summary>
  4376. /// Performs action on all avatars in the scene (root scene presences)
  4377. /// Avatars may be an NPC or a 'real' client.
  4378. /// </summary>
  4379. /// <param name="action"></param>
  4380. public void ForEachRootScenePresence(Action<ScenePresence> action)
  4381. {
  4382. m_sceneGraph.ForEachAvatar(action);
  4383. }
  4384. /// <summary>
  4385. /// Performs action on all scene presences (root and child)
  4386. /// </summary>
  4387. /// <param name="action"></param>
  4388. public void ForEachScenePresence(Action<ScenePresence> action)
  4389. {
  4390. m_sceneGraph.ForEachScenePresence(action);
  4391. }
  4392. /// <summary>
  4393. /// Get all the scene object groups.
  4394. /// </summary>
  4395. /// <returns>
  4396. /// The scene object groups. If the scene is empty then an empty list is returned.
  4397. /// </returns>
  4398. public List<SceneObjectGroup> GetSceneObjectGroups()
  4399. {
  4400. return m_sceneGraph.GetSceneObjectGroups();
  4401. }
  4402. /// <summary>
  4403. /// Get a group via its UUID
  4404. /// </summary>
  4405. /// <param name="fullID"></param>
  4406. /// <returns>null if no group with that id exists</returns>
  4407. public SceneObjectGroup GetSceneObjectGroup(UUID fullID)
  4408. {
  4409. return m_sceneGraph.GetSceneObjectGroup(fullID);
  4410. }
  4411. /// <summary>
  4412. /// Get a group via its local ID
  4413. /// </summary>
  4414. /// <remarks>This will only return a group if the local ID matches a root part</remarks>
  4415. /// <param name="localID"></param>
  4416. /// <returns>null if no group with that id exists</returns>
  4417. public SceneObjectGroup GetSceneObjectGroup(uint localID)
  4418. {
  4419. return m_sceneGraph.GetSceneObjectGroup(localID);
  4420. }
  4421. /// <summary>
  4422. /// Get a group by name from the scene (will return the first
  4423. /// found, if there are more than one prim with the same name)
  4424. /// </summary>
  4425. /// <param name="name"></param>
  4426. /// <returns>null if no group with that name exists</returns>
  4427. public SceneObjectGroup GetSceneObjectGroup(string name)
  4428. {
  4429. return m_sceneGraph.GetSceneObjectGroup(name);
  4430. }
  4431. /// <summary>
  4432. /// Attempt to get the SOG via its UUID
  4433. /// </summary>
  4434. /// <param name="fullID"></param>
  4435. /// <param name="sog"></param>
  4436. /// <returns></returns>
  4437. public bool TryGetSceneObjectGroup(UUID fullID, out SceneObjectGroup sog)
  4438. {
  4439. sog = GetSceneObjectGroup(fullID);
  4440. return sog != null;
  4441. }
  4442. /// <summary>
  4443. /// Get a prim by name from the scene (will return the first
  4444. /// found, if there are more than one prim with the same name)
  4445. /// </summary>
  4446. /// <param name="name"></param>
  4447. /// <returns></returns>
  4448. public SceneObjectPart GetSceneObjectPart(string name)
  4449. {
  4450. return m_sceneGraph.GetSceneObjectPart(name);
  4451. }
  4452. /// <summary>
  4453. /// Get a prim via its local id
  4454. /// </summary>
  4455. /// <param name="localID"></param>
  4456. /// <returns></returns>
  4457. public SceneObjectPart GetSceneObjectPart(uint localID)
  4458. {
  4459. return m_sceneGraph.GetSceneObjectPart(localID);
  4460. }
  4461. /// <summary>
  4462. /// Get a prim via its UUID
  4463. /// </summary>
  4464. /// <param name="fullID"></param>
  4465. /// <returns></returns>
  4466. public SceneObjectPart GetSceneObjectPart(UUID fullID)
  4467. {
  4468. return m_sceneGraph.GetSceneObjectPart(fullID);
  4469. }
  4470. /// <summary>
  4471. /// Attempt to get a prim via its UUID
  4472. /// </summary>
  4473. /// <param name="fullID"></param>
  4474. /// <param name="sop"></param>
  4475. /// <returns></returns>
  4476. public bool TryGetSceneObjectPart(UUID fullID, out SceneObjectPart sop)
  4477. {
  4478. sop = GetSceneObjectPart(fullID);
  4479. return sop != null;
  4480. }
  4481. /// <summary>
  4482. /// Get a scene object group that contains the prim with the given local id
  4483. /// </summary>
  4484. /// <param name="localID"></param>
  4485. /// <returns>null if no scene object group containing that prim is found</returns>
  4486. public SceneObjectGroup GetGroupByPrim(uint localID)
  4487. {
  4488. return m_sceneGraph.GetGroupByPrim(localID);
  4489. }
  4490. /// <summary>
  4491. /// Get a scene object group that contains the prim with the given uuid
  4492. /// </summary>
  4493. /// <param name="fullID"></param>
  4494. /// <returns>null if no scene object group containing that prim is found</returns>
  4495. public SceneObjectGroup GetGroupByPrim(UUID fullID)
  4496. {
  4497. return m_sceneGraph.GetGroupByPrim(fullID);
  4498. }
  4499. public override bool TryGetScenePresence(UUID agentID, out ScenePresence sp)
  4500. {
  4501. return m_sceneGraph.TryGetScenePresence(agentID, out sp);
  4502. }
  4503. public bool TryGetAvatarByName(string avatarName, out ScenePresence avatar)
  4504. {
  4505. return m_sceneGraph.TryGetAvatarByName(avatarName, out avatar);
  4506. }
  4507. /// <summary>
  4508. /// Perform an action on all clients with an avatar in this scene (root only)
  4509. /// </summary>
  4510. /// <param name="action"></param>
  4511. public void ForEachRootClient(Action<IClientAPI> action)
  4512. {
  4513. ForEachRootScenePresence(delegate(ScenePresence presence)
  4514. {
  4515. action(presence.ControllingClient);
  4516. });
  4517. }
  4518. /// <summary>
  4519. /// Perform an action on all clients connected to the region (root and child)
  4520. /// </summary>
  4521. /// <param name="action"></param>
  4522. public void ForEachClient(Action<IClientAPI> action)
  4523. {
  4524. m_clientManager.ForEach(action);
  4525. }
  4526. public int GetNumberOfClients()
  4527. {
  4528. return m_clientManager.Count;
  4529. }
  4530. public bool TryGetClient(UUID avatarID, out IClientAPI client)
  4531. {
  4532. return m_clientManager.TryGetValue(avatarID, out client);
  4533. }
  4534. public bool TryGetClient(System.Net.IPEndPoint remoteEndPoint, out IClientAPI client)
  4535. {
  4536. return m_clientManager.TryGetValue(remoteEndPoint, out client);
  4537. }
  4538. public void ForEachSOG(Action<SceneObjectGroup> action)
  4539. {
  4540. m_sceneGraph.ForEachSOG(action);
  4541. }
  4542. /// <summary>
  4543. /// Returns a list of the entities in the scene. This is a new list so operations perform on the list itself
  4544. /// will not affect the original list of objects in the scene.
  4545. /// </summary>
  4546. /// <returns></returns>
  4547. public EntityBase[] GetEntities()
  4548. {
  4549. return m_sceneGraph.GetEntities();
  4550. }
  4551. #endregion
  4552. // Commented pending deletion since this method no longer appears to do anything at all
  4553. // public bool NeedSceneCacheClear(UUID agentID)
  4554. // {
  4555. // IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
  4556. // if (inv == null)
  4557. // return true;
  4558. //
  4559. // return inv.NeedSceneCacheClear(agentID, this);
  4560. // }
  4561. public void CleanTempObjects()
  4562. {
  4563. DateTime now = DateTime.UtcNow;
  4564. EntityBase[] entities = GetEntities();
  4565. foreach (EntityBase obj in entities)
  4566. {
  4567. if (obj is SceneObjectGroup)
  4568. {
  4569. SceneObjectGroup grp = (SceneObjectGroup)obj;
  4570. if (!grp.IsDeleted)
  4571. {
  4572. if ((grp.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
  4573. {
  4574. if (grp.GetSittingAvatarsCount() == 0 && grp.RootPart.Expires <= now)
  4575. DeleteSceneObject(grp, false);
  4576. }
  4577. }
  4578. }
  4579. }
  4580. }
  4581. public void DeleteFromStorage(UUID uuid)
  4582. {
  4583. SimulationDataService.RemoveObject(uuid, RegionInfo.RegionID);
  4584. }
  4585. public int GetHealth(out int flags, out string message)
  4586. {
  4587. // Returns:
  4588. // 1 = sim is up and accepting http requests. The heartbeat has
  4589. // stopped and the sim is probably locked up, but a remote
  4590. // admin restart may succeed
  4591. //
  4592. // 2 = Sim is up and the heartbeat is running. The sim is likely
  4593. // usable for people within
  4594. //
  4595. // 3 = Sim is up and one packet thread is running. Sim is
  4596. // unstable and will not accept new logins
  4597. //
  4598. // 4 = Sim is up and both packet threads are running. Sim is
  4599. // likely usable
  4600. //
  4601. // 5 = We have seen a new user enter within the past 4 minutes
  4602. // which can be seen as positive confirmation of sim health
  4603. //
  4604. int health = 1; // Start at 1, means we're up
  4605. flags = 0;
  4606. message = String.Empty;
  4607. CheckHeartbeat();
  4608. if (m_firstHeartbeat || (m_lastIncoming == 0 && m_lastOutgoing == 0))
  4609. {
  4610. // We're still starting
  4611. // 0 means "in startup", it can't happen another way, since
  4612. // to get here, we must be able to accept http connections
  4613. return 0;
  4614. }
  4615. if ((Util.EnvironmentTickCountSubtract(m_lastFrameTick)) < 2000)
  4616. {
  4617. health+=1;
  4618. flags |= 1;
  4619. }
  4620. if (Util.EnvironmentTickCountSubtract(m_lastIncoming) < 2000)
  4621. {
  4622. health+=1;
  4623. flags |= 2;
  4624. }
  4625. if (Util.EnvironmentTickCountSubtract(m_lastOutgoing) < 2000)
  4626. {
  4627. health+=1;
  4628. flags |= 4;
  4629. }
  4630. /*
  4631. else
  4632. {
  4633. int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
  4634. System.Diagnostics.Process proc = new System.Diagnostics.Process();
  4635. proc.EnableRaisingEvents=false;
  4636. proc.StartInfo.FileName = "/bin/kill";
  4637. proc.StartInfo.Arguments = "-QUIT " + pid.ToString();
  4638. proc.Start();
  4639. proc.WaitForExit();
  4640. Thread.Sleep(1000);
  4641. Environment.Exit(1);
  4642. }
  4643. */
  4644. if (flags != 7)
  4645. return health;
  4646. // A login in the last 4 mins? We can't be doing too badly
  4647. //
  4648. if (Util.EnvironmentTickCountSubtract(m_LastLogin) < 240000)
  4649. health++;
  4650. else
  4651. return health;
  4652. return health;
  4653. }
  4654. // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
  4655. // update non-physical objects like the joint proxy objects that represent the position
  4656. // of the joints in the scene.
  4657. // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
  4658. // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
  4659. // from within the OdePhysicsScene.
  4660. protected internal void jointMoved(PhysicsJoint joint)
  4661. {
  4662. // m_parentScene.PhysicsScene.DumpJointInfo(); // non-thread-locked version; we should already be in a lock (OdeLock) when this callback is invoked
  4663. SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
  4664. if (jointProxyObject == null)
  4665. {
  4666. jointErrorMessage(joint, "WARNING, joint proxy not found, name " + joint.ObjectNameInScene);
  4667. return;
  4668. }
  4669. // now update the joint proxy object in the scene to have the position of the joint as returned by the physics engine
  4670. SceneObjectPart trackedBody = GetSceneObjectPart(joint.TrackedBodyName); // FIXME: causes a sequential lookup
  4671. if (trackedBody == null) return; // the actor may have been deleted but the joint still lingers around a few frames waiting for deletion. during this time, trackedBody is NULL to prevent further motion of the joint proxy.
  4672. jointProxyObject.Velocity = trackedBody.Velocity;
  4673. jointProxyObject.AngularVelocity = trackedBody.AngularVelocity;
  4674. switch (joint.Type)
  4675. {
  4676. case PhysicsJointType.Ball:
  4677. {
  4678. Vector3 jointAnchor = PhysicsScene.GetJointAnchor(joint);
  4679. Vector3 proxyPos = jointAnchor;
  4680. jointProxyObject.ParentGroup.UpdateGroupPosition(proxyPos); // schedules the entire group for a terse update
  4681. }
  4682. break;
  4683. case PhysicsJointType.Hinge:
  4684. {
  4685. Vector3 jointAnchor = PhysicsScene.GetJointAnchor(joint);
  4686. // Normally, we would just ask the physics scene to return the axis for the joint.
  4687. // Unfortunately, ODE sometimes returns <0,0,0> for the joint axis, which should
  4688. // never occur. Therefore we cannot rely on ODE to always return a correct joint axis.
  4689. // Therefore the following call does not always work:
  4690. //PhysicsVector phyJointAxis = _PhyScene.GetJointAxis(joint);
  4691. // instead we compute the joint orientation by saving the original joint orientation
  4692. // relative to one of the jointed bodies, and applying this transformation
  4693. // to the current position of the jointed bodies (the tracked body) to compute the
  4694. // current joint orientation.
  4695. if (joint.TrackedBodyName == null)
  4696. {
  4697. jointErrorMessage(joint, "joint.TrackedBodyName is null, joint " + joint.ObjectNameInScene);
  4698. }
  4699. Vector3 proxyPos = jointAnchor;
  4700. Quaternion q = trackedBody.RotationOffset * joint.LocalRotation;
  4701. jointProxyObject.ParentGroup.UpdateGroupPosition(proxyPos); // schedules the entire group for a terse update
  4702. jointProxyObject.ParentGroup.UpdateGroupRotationR(q); // schedules the entire group for a terse update
  4703. }
  4704. break;
  4705. }
  4706. }
  4707. // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
  4708. // update non-physical objects like the joint proxy objects that represent the position
  4709. // of the joints in the scene.
  4710. // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
  4711. // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
  4712. // from within the OdePhysicsScene.
  4713. protected internal void jointDeactivated(PhysicsJoint joint)
  4714. {
  4715. //m_log.Debug("[NINJA] SceneGraph.jointDeactivated, joint:" + joint.ObjectNameInScene);
  4716. SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
  4717. if (jointProxyObject == null)
  4718. {
  4719. jointErrorMessage(joint, "WARNING, trying to deactivate (stop interpolation of) joint proxy, but not found, name " + joint.ObjectNameInScene);
  4720. return;
  4721. }
  4722. // turn the proxy non-physical, which also stops its client-side interpolation
  4723. bool wasUsingPhysics = ((jointProxyObject.Flags & PrimFlags.Physics) != 0);
  4724. if (wasUsingPhysics)
  4725. {
  4726. jointProxyObject.UpdatePrimFlags(false, false, true, false,false); // FIXME: possible deadlock here; check to make sure all the scene alterations set into motion here won't deadlock
  4727. }
  4728. }
  4729. // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
  4730. // alert the user of errors by using the debug channel in the same way that scripts alert
  4731. // the user of compile errors.
  4732. // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
  4733. // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
  4734. // from within the OdePhysicsScene.
  4735. public void jointErrorMessage(PhysicsJoint joint, string message)
  4736. {
  4737. if (joint != null)
  4738. {
  4739. if (joint.ErrorMessageCount > PhysicsJoint.maxErrorMessages)
  4740. return;
  4741. SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
  4742. if (jointProxyObject != null)
  4743. {
  4744. SimChat(Utils.StringToBytes("[NINJA]: " + message),
  4745. ChatTypeEnum.DebugChannel,
  4746. 2147483647,
  4747. jointProxyObject.AbsolutePosition,
  4748. jointProxyObject.Name,
  4749. jointProxyObject.UUID,
  4750. false);
  4751. joint.ErrorMessageCount++;
  4752. if (joint.ErrorMessageCount > PhysicsJoint.maxErrorMessages)
  4753. {
  4754. SimChat(Utils.StringToBytes("[NINJA]: Too many messages for this joint, suppressing further messages."),
  4755. ChatTypeEnum.DebugChannel,
  4756. 2147483647,
  4757. jointProxyObject.AbsolutePosition,
  4758. jointProxyObject.Name,
  4759. jointProxyObject.UUID,
  4760. false);
  4761. }
  4762. }
  4763. else
  4764. {
  4765. // couldn't find the joint proxy object; the error message is silently suppressed
  4766. }
  4767. }
  4768. }
  4769. public Scene ConsoleScene()
  4770. {
  4771. if (MainConsole.Instance == null)
  4772. return null;
  4773. if (MainConsole.Instance.ConsoleScene is Scene)
  4774. return (Scene)MainConsole.Instance.ConsoleScene;
  4775. return null;
  4776. }
  4777. // Get terrain height at the specified <x,y> location.
  4778. // Presumes the underlying implementation is a heightmap which is a 1m grid.
  4779. // Finds heightmap grid points before and after the point and
  4780. // does a linear approximation of the height at this intermediate point.
  4781. public float GetGroundHeight(float x, float y)
  4782. {
  4783. if (x < 0)
  4784. x = 0;
  4785. if (x >= Heightmap.Width)
  4786. x = Heightmap.Width - 1;
  4787. if (y < 0)
  4788. y = 0;
  4789. if (y >= Heightmap.Height)
  4790. y = Heightmap.Height - 1;
  4791. Vector3 p0 = new Vector3(x, y, (float)Heightmap[(int)x, (int)y]);
  4792. Vector3 p1 = p0;
  4793. Vector3 p2 = p0;
  4794. p1.X += 1.0f;
  4795. if (p1.X < Heightmap.Width)
  4796. p1.Z = (float)Heightmap[(int)p1.X, (int)p1.Y];
  4797. p2.Y += 1.0f;
  4798. if (p2.Y < Heightmap.Height)
  4799. p2.Z = (float)Heightmap[(int)p2.X, (int)p2.Y];
  4800. Vector3 v0 = new Vector3(p1.X - p0.X, p1.Y - p0.Y, p1.Z - p0.Z);
  4801. Vector3 v1 = new Vector3(p2.X - p0.X, p2.Y - p0.Y, p2.Z - p0.Z);
  4802. v0.Normalize();
  4803. v1.Normalize();
  4804. Vector3 vsn = new Vector3();
  4805. vsn.X = (v0.Y * v1.Z) - (v0.Z * v1.Y);
  4806. vsn.Y = (v0.Z * v1.X) - (v0.X * v1.Z);
  4807. vsn.Z = (v0.X * v1.Y) - (v0.Y * v1.X);
  4808. vsn.Normalize();
  4809. float xdiff = x - (float)((int)x);
  4810. float ydiff = y - (float)((int)y);
  4811. return (((vsn.X * xdiff) + (vsn.Y * ydiff)) / (-1 * vsn.Z)) + p0.Z;
  4812. }
  4813. private void CheckHeartbeat()
  4814. {
  4815. if (m_firstHeartbeat)
  4816. return;
  4817. if ((Util.EnvironmentTickCountSubtract(m_lastFrameTick)) > 5000)
  4818. Start();
  4819. }
  4820. public override ISceneObject DeserializeObject(string representation)
  4821. {
  4822. return SceneObjectSerializer.FromXml2Format(representation);
  4823. }
  4824. public override bool AllowScriptCrossings
  4825. {
  4826. get { return m_allowScriptCrossings; }
  4827. }
  4828. public Vector3 GetNearestAllowedPosition(ScenePresence avatar)
  4829. {
  4830. return GetNearestAllowedPosition(avatar, null);
  4831. }
  4832. public Vector3 GetNearestAllowedPosition(ScenePresence avatar, ILandObject excludeParcel)
  4833. {
  4834. Vector3 pos = avatar.AbsolutePosition;
  4835. ILandObject nearestParcel = GetNearestAllowedParcel(avatar.UUID, pos.X, pos.Y, excludeParcel);
  4836. if (nearestParcel != null)
  4837. {
  4838. Vector2? nearestPoint = null;
  4839. Vector3 dir = -avatar.Velocity;
  4840. float dirlen = dir.Length();
  4841. if(dirlen > 1.0f)
  4842. //Try to get a location that feels like where they came from
  4843. nearestPoint = nearestParcel.GetNearestPointAlongDirection(pos, dir);
  4844. if (nearestPoint == null)
  4845. nearestPoint = nearestParcel.GetNearestPoint(pos);
  4846. if (nearestPoint != null)
  4847. {
  4848. return GetPositionAtAvatarHeightOrGroundHeight(avatar,
  4849. nearestPoint.Value.X, nearestPoint.Value.Y);
  4850. }
  4851. ILandObject dest = LandChannel.GetLandObject(avatar.lastKnownAllowedPosition.X, avatar.lastKnownAllowedPosition.Y);
  4852. if (dest != excludeParcel)
  4853. {
  4854. // Ultimate backup if we have no idea where they are and
  4855. // the last allowed position was in another parcel
  4856. m_log.Debug("Have no idea where they are, sending them to: " + avatar.lastKnownAllowedPosition.ToString());
  4857. return avatar.lastKnownAllowedPosition;
  4858. }
  4859. // else fall through to region edge
  4860. }
  4861. //Go to the edge, this happens in teleporting to a region with no available parcels
  4862. Vector3 nearestRegionEdgePoint = GetNearestRegionEdgePosition(avatar);
  4863. //Debug.WriteLine("They are really in a place they don't belong, sending them to: " + nearestRegionEdgePoint.ToString());
  4864. return nearestRegionEdgePoint;
  4865. }
  4866. private Vector3 GetParcelCenterAtGround(ILandObject parcel)
  4867. {
  4868. Vector2 center = parcel.CenterPoint;
  4869. return GetPositionAtGround(center.X, center.Y);
  4870. }
  4871. public ILandObject GetNearestAllowedParcel(UUID avatarId, float x, float y)
  4872. {
  4873. return GetNearestAllowedParcel(avatarId, x, y, null);
  4874. }
  4875. public ILandObject GetNearestAllowedParcel(UUID avatarId, float x, float y, ILandObject excludeParcel)
  4876. {
  4877. if(LandChannel == null)
  4878. return null;
  4879. List<ILandObject> all = LandChannel.AllParcels();
  4880. if(all == null || all.Count == 0)
  4881. return null;
  4882. float minParcelDistanceSQ = float.MaxValue;
  4883. ILandObject nearestParcel = null;
  4884. Vector2 curCenter;
  4885. float parcelDistanceSQ;
  4886. foreach (var parcel in all)
  4887. {
  4888. if (parcel != excludeParcel && !parcel.IsEitherBannedOrRestricted(avatarId))
  4889. {
  4890. curCenter = parcel.CenterPoint;
  4891. curCenter.X -= x;
  4892. curCenter.Y -= y;
  4893. parcelDistanceSQ = curCenter.LengthSquared();
  4894. if (parcelDistanceSQ < minParcelDistanceSQ)
  4895. {
  4896. minParcelDistanceSQ = parcelDistanceSQ;
  4897. nearestParcel = parcel;
  4898. }
  4899. }
  4900. }
  4901. return nearestParcel;
  4902. }
  4903. private Vector2 GetParcelSafeCorner(ILandObject parcel)
  4904. {
  4905. Vector2 place = parcel.StartPoint;
  4906. place.X += 2f;
  4907. place.Y += 2f;
  4908. return place;
  4909. }
  4910. private Vector3 GetNearestRegionEdgePosition(ScenePresence avatar)
  4911. {
  4912. float posX = avatar.AbsolutePosition.X;
  4913. float posY = avatar.AbsolutePosition.Y;
  4914. float regionSizeX = RegionInfo.RegionSizeX;
  4915. float halfRegionSizeX = regionSizeX * 0.5f;
  4916. float regionSizeY = RegionInfo.RegionSizeY;
  4917. float halfRegionSizeY = regionSizeY * 0.5f;
  4918. float xdistance = posX < halfRegionSizeX ? posX : regionSizeX - posX;
  4919. float ydistance = posY < halfRegionSizeY ? posY : regionSizeY - posY;
  4920. //find out what vertical edge to go to
  4921. if (xdistance < ydistance)
  4922. {
  4923. if (posX < halfRegionSizeX)
  4924. return GetPositionAtAvatarHeightOrGroundHeight(avatar, 0.5f, posY);
  4925. else
  4926. return GetPositionAtAvatarHeightOrGroundHeight(avatar, regionSizeX - 0.5f, posY);
  4927. }
  4928. //find out what horizontal edge to go to
  4929. else
  4930. {
  4931. if (posY < halfRegionSizeY)
  4932. return GetPositionAtAvatarHeightOrGroundHeight(avatar, posX, 0.5f);
  4933. else
  4934. return GetPositionAtAvatarHeightOrGroundHeight(avatar, posX, regionSizeY - 0.5f);
  4935. }
  4936. }
  4937. private Vector3 GetPositionAtAvatarHeightOrGroundHeight(ScenePresence avatar, float x, float y)
  4938. {
  4939. Vector3 ground = GetPositionAtGround(x, y);
  4940. if(avatar.Appearance != null)
  4941. ground.Z += avatar.Appearance.AvatarHeight * 0.5f;
  4942. else
  4943. ground.Z += 0.8f;
  4944. if (avatar.AbsolutePosition.Z > ground.Z)
  4945. {
  4946. ground.Z = avatar.AbsolutePosition.Z;
  4947. }
  4948. return ground;
  4949. }
  4950. private Vector3 GetPositionAtGround(float x, float y)
  4951. {
  4952. return new Vector3(x, y, GetGroundHeight(x, y));
  4953. }
  4954. public List<UUID> GetEstateRegions(int estateID)
  4955. {
  4956. IEstateDataService estateDataService = EstateDataService;
  4957. if (estateDataService == null)
  4958. return new List<UUID>(0);
  4959. return estateDataService.GetRegions(estateID);
  4960. }
  4961. public void ReloadEstateData()
  4962. {
  4963. IEstateDataService estateDataService = EstateDataService;
  4964. if (estateDataService != null)
  4965. {
  4966. RegionInfo.EstateSettings = estateDataService.LoadEstateSettings(RegionInfo.RegionID, false);
  4967. TriggerEstateSunUpdate();
  4968. }
  4969. }
  4970. public void TriggerEstateSunUpdate()
  4971. {
  4972. EventManager.TriggerEstateToolsSunUpdate(RegionInfo.RegionHandle);
  4973. }
  4974. private void HandleReloadEstate(string module, string[] cmd)
  4975. {
  4976. if (MainConsole.Instance.ConsoleScene == null ||
  4977. (MainConsole.Instance.ConsoleScene is Scene &&
  4978. (Scene)MainConsole.Instance.ConsoleScene == this))
  4979. {
  4980. ReloadEstateData();
  4981. }
  4982. }
  4983. /// <summary>
  4984. /// Get the volume of space that will encompass all the given objects.
  4985. /// </summary>
  4986. /// <param name="objects"></param>
  4987. /// <param name="minX"></param>
  4988. /// <param name="maxX"></param>
  4989. /// <param name="minY"></param>
  4990. /// <param name="maxY"></param>
  4991. /// <param name="minZ"></param>
  4992. /// <param name="maxZ"></param>
  4993. /// <returns></returns>
  4994. public static Vector3[] GetCombinedBoundingBox(
  4995. List<SceneObjectGroup> objects,
  4996. out float minX, out float maxX, out float minY, out float maxY, out float minZ, out float maxZ)
  4997. {
  4998. minX = float.MaxValue;
  4999. maxX = float.MinValue;
  5000. minY = float.MaxValue;
  5001. maxY = float.MinValue;
  5002. minZ = float.MaxValue;
  5003. maxZ = float.MinValue;
  5004. List<Vector3> offsets = new List<Vector3>();
  5005. foreach (SceneObjectGroup g in objects)
  5006. {
  5007. float ominX, ominY, ominZ, omaxX, omaxY, omaxZ;
  5008. Vector3 vec = g.AbsolutePosition;
  5009. g.GetAxisAlignedBoundingBoxRaw(out ominX, out omaxX, out ominY, out omaxY, out ominZ, out omaxZ);
  5010. // m_log.DebugFormat(
  5011. // "[SCENE]: For {0} found AxisAlignedBoundingBoxRaw {1}, {2}",
  5012. // g.Name, new Vector3(ominX, ominY, ominZ), new Vector3(omaxX, omaxY, omaxZ));
  5013. ominX += vec.X;
  5014. omaxX += vec.X;
  5015. ominY += vec.Y;
  5016. omaxY += vec.Y;
  5017. ominZ += vec.Z;
  5018. omaxZ += vec.Z;
  5019. if (minX > ominX)
  5020. minX = ominX;
  5021. if (minY > ominY)
  5022. minY = ominY;
  5023. if (minZ > ominZ)
  5024. minZ = ominZ;
  5025. if (maxX < omaxX)
  5026. maxX = omaxX;
  5027. if (maxY < omaxY)
  5028. maxY = omaxY;
  5029. if (maxZ < omaxZ)
  5030. maxZ = omaxZ;
  5031. }
  5032. foreach (SceneObjectGroup g in objects)
  5033. {
  5034. Vector3 vec = g.AbsolutePosition;
  5035. vec.X -= minX;
  5036. vec.Y -= minY;
  5037. vec.Z -= minZ;
  5038. offsets.Add(vec);
  5039. }
  5040. return offsets.ToArray();
  5041. }
  5042. /// <summary>
  5043. /// Regenerate the maptile for this scene.
  5044. /// </summary>
  5045. /// <param name="sender"></param>
  5046. /// <param name="e"></param>
  5047. private void RegenerateMaptile()
  5048. {
  5049. IWorldMapModule mapModule = RequestModuleInterface<IWorldMapModule>();
  5050. if (mapModule != null)
  5051. mapModule.GenerateMaptile();
  5052. }
  5053. // public void CleanDroppedAttachments()
  5054. // {
  5055. // List<SceneObjectGroup> objectsToDelete =
  5056. // new List<SceneObjectGroup>();
  5057. //
  5058. // lock (m_cleaningAttachments)
  5059. // {
  5060. // ForEachSOG(delegate (SceneObjectGroup grp)
  5061. // {
  5062. // if (grp.RootPart.Shape.PCode == 0 && grp.RootPart.Shape.State != 0 && (!objectsToDelete.Contains(grp)))
  5063. // {
  5064. // UUID agentID = grp.OwnerID;
  5065. // if (agentID == UUID.Zero)
  5066. // {
  5067. // objectsToDelete.Add(grp);
  5068. // return;
  5069. // }
  5070. //
  5071. // ScenePresence sp = GetScenePresence(agentID);
  5072. // if (sp == null)
  5073. // {
  5074. // objectsToDelete.Add(grp);
  5075. // return;
  5076. // }
  5077. // }
  5078. // });
  5079. // }
  5080. //
  5081. // foreach (SceneObjectGroup grp in objectsToDelete)
  5082. // {
  5083. // m_log.InfoFormat("[SCENE]: Deleting dropped attachment {0} of user {1}", grp.UUID, grp.OwnerID);
  5084. // DeleteSceneObject(grp, true);
  5085. // }
  5086. // }
  5087. public void ThreadAlive(int threadCode)
  5088. {
  5089. switch(threadCode)
  5090. {
  5091. case 1: // Incoming
  5092. m_lastIncoming = Util.EnvironmentTickCount();
  5093. break;
  5094. case 2: // Incoming
  5095. m_lastOutgoing = Util.EnvironmentTickCount();
  5096. break;
  5097. }
  5098. }
  5099. public void RegenerateMaptileAndReregister(object sender, ElapsedEventArgs e)
  5100. {
  5101. RegenerateMaptile();
  5102. // We need to propagate the new image UUID to the grid service
  5103. // so that all simulators can retrieve it
  5104. string error = GridService.RegisterRegion(RegionInfo.ScopeID, new GridRegion(RegionInfo));
  5105. if (error != string.Empty)
  5106. throw new Exception(error);
  5107. }
  5108. /// <summary>
  5109. /// This method is called across the simulation connector to
  5110. /// determine if a given agent is allowed in this region
  5111. /// AS A ROOT AGENT
  5112. /// </summary>
  5113. /// <remarks>
  5114. /// Returning false here will prevent them
  5115. /// from logging into the region, teleporting into the region
  5116. /// or corssing the broder walking, but will NOT prevent
  5117. /// child agent creation, thereby emulating the SL behavior.
  5118. /// </remarks>
  5119. /// <param name='agentID'>The visitor's User ID</param>
  5120. /// <param name="agentHomeURI">The visitor's Home URI (may be null)</param>
  5121. /// <param name='position'></param>
  5122. /// <param name='reason'></param>
  5123. /// <returns></returns>
  5124. public bool QueryAccess(UUID agentID, string agentHomeURI, bool viaTeleport, Vector3 position, List<UUID> features, out string reason)
  5125. {
  5126. reason = string.Empty;
  5127. if (Permissions.IsGod(agentID))
  5128. return true;
  5129. if (!AllowAvatarCrossing && !viaTeleport)
  5130. {
  5131. reason = "Region Crossing not allowed";
  5132. return false;
  5133. }
  5134. bool isAdmin = Permissions.IsAdministrator(agentID);
  5135. bool isManager = Permissions.IsEstateManager(agentID);
  5136. // FIXME: Root agent count is currently known to be inaccurate. This forces a recount before we check.
  5137. // However, the long term fix is to make sure root agent count is always accurate.
  5138. m_sceneGraph.RecalculateStats();
  5139. int num = m_sceneGraph.GetRootAgentCount();
  5140. if (num >= RegionInfo.RegionSettings.AgentLimit)
  5141. {
  5142. if (!(isAdmin || isManager))
  5143. {
  5144. reason = "The region is full";
  5145. m_log.DebugFormat(
  5146. "[SCENE]: Denying presence with id {0} entry into {1} since region is at agent limit of {2}",
  5147. agentID, RegionInfo.RegionName, RegionInfo.RegionSettings.AgentLimit);
  5148. return false;
  5149. }
  5150. }
  5151. ScenePresence presence = GetScenePresence(agentID);
  5152. IClientAPI client = null;
  5153. AgentCircuitData aCircuit = null;
  5154. if (presence != null)
  5155. {
  5156. client = presence.ControllingClient;
  5157. if (client != null)
  5158. aCircuit = client.RequestClientInfo();
  5159. }
  5160. // We may be called before there is a presence or a client.
  5161. // Fake AgentCircuitData to keep IAuthorizationModule smiling
  5162. if (client == null)
  5163. {
  5164. aCircuit = new AgentCircuitData();
  5165. aCircuit.AgentID = agentID;
  5166. aCircuit.firstname = String.Empty;
  5167. aCircuit.lastname = String.Empty;
  5168. }
  5169. try
  5170. {
  5171. if (!AuthorizeUser(aCircuit, false, out reason))
  5172. {
  5173. //m_log.DebugFormat("[SCENE]: Denying access for {0}", agentID);
  5174. // reason = "Region authorization fail";
  5175. return false;
  5176. }
  5177. }
  5178. catch (Exception e)
  5179. {
  5180. m_log.DebugFormat("[SCENE]: Exception authorizing agent: {0} " + e.StackTrace, e.Message);
  5181. reason = "Error authorizing agent: " + e.Message;
  5182. return false;
  5183. }
  5184. // last check aditional land access restrictions and relocations
  5185. // if crossing (viaTeleport false) check only the specified parcel
  5186. return CheckLandPositionAccess(agentID, viaTeleport, true, position, out reason);
  5187. }
  5188. // check access to land.
  5189. public bool CheckLandPositionAccess(UUID agentID, bool NotCrossing, bool checkTeleHub, Vector3 position, out string reason)
  5190. {
  5191. reason = string.Empty;
  5192. if (Permissions.IsGod(agentID))
  5193. return true;
  5194. // Permissions.IsAdministrator is the same as IsGod for now
  5195. // bool isAdmin = Permissions.IsAdministrator(agentID);
  5196. // if(isAdmin)
  5197. // return true;
  5198. // also honor estate managers access rights
  5199. bool isManager = Permissions.IsEstateManager(agentID);
  5200. if(isManager)
  5201. return true;
  5202. if (NotCrossing)
  5203. {
  5204. if (!RegionInfo.EstateSettings.AllowDirectTeleport)
  5205. {
  5206. SceneObjectGroup telehub;
  5207. if (RegionInfo.RegionSettings.TelehubObject != UUID.Zero && (telehub = GetSceneObjectGroup (RegionInfo.RegionSettings.TelehubObject)) != null && checkTeleHub)
  5208. {
  5209. bool banned = true;
  5210. bool validTelehub = false;
  5211. List<SpawnPoint> spawnPoints = RegionInfo.RegionSettings.SpawnPoints();
  5212. Vector3 spawnPoint;
  5213. ILandObject land = null;
  5214. Vector3 telehubPosition = telehub.AbsolutePosition;
  5215. if(spawnPoints.Count == 0)
  5216. {
  5217. // will this ever happen?
  5218. // if so use the telehub object position
  5219. spawnPoint = telehubPosition;
  5220. land = LandChannel.GetLandObject(spawnPoint.X, spawnPoint.Y);
  5221. if(land != null && !land.IsEitherBannedOrRestricted(agentID))
  5222. {
  5223. banned = false;
  5224. validTelehub = true;
  5225. }
  5226. }
  5227. else
  5228. {
  5229. Quaternion telehubRotation = telehub.GroupRotation;
  5230. foreach (SpawnPoint spawn in spawnPoints)
  5231. {
  5232. spawnPoint = spawn.GetLocation(telehubPosition, telehubRotation);
  5233. land = LandChannel.GetLandObject(spawnPoint.X, spawnPoint.Y);
  5234. if (land == null)
  5235. continue;
  5236. validTelehub = true;
  5237. if (!land.IsEitherBannedOrRestricted(agentID))
  5238. {
  5239. banned = false;
  5240. break;
  5241. }
  5242. }
  5243. }
  5244. if(validTelehub)
  5245. {
  5246. if (banned)
  5247. {
  5248. reason = "No suitable landing point found";
  5249. return false;
  5250. }
  5251. else
  5252. return true;
  5253. }
  5254. // possible broken telehub, fall into normal check
  5255. }
  5256. }
  5257. float posX = position.X;
  5258. float posY = position.Y;
  5259. // allow position relocation
  5260. if (!TestLandRestrictions(agentID, out reason, ref posX, ref posY))
  5261. {
  5262. // m_log.DebugFormat("[SCENE]: Denying {0} because they are banned on all parcels", agentID);
  5263. reason = "You dont have access to the region parcels";
  5264. return false;
  5265. }
  5266. }
  5267. else // check for query region crossing only
  5268. {
  5269. // no relocation allowed on crossings
  5270. ILandObject land = LandChannel.GetLandObject(position.X, position.Y);
  5271. if (land == null)
  5272. {
  5273. reason = "No parcel found";
  5274. return false;
  5275. }
  5276. bool banned = land.IsBannedFromLand(agentID);
  5277. bool restricted = land.IsRestrictedFromLand(agentID);
  5278. if (banned || restricted)
  5279. {
  5280. if (banned)
  5281. reason = "You are banned from the parcel";
  5282. else
  5283. reason = "The parcel is restricted";
  5284. return false;
  5285. }
  5286. }
  5287. return true;
  5288. }
  5289. public void StartTimerWatchdog()
  5290. {
  5291. m_timerWatchdog.Interval = 1000;
  5292. m_timerWatchdog.Elapsed += TimerWatchdog;
  5293. m_timerWatchdog.AutoReset = true;
  5294. m_timerWatchdog.Start();
  5295. }
  5296. public void TimerWatchdog(object sender, ElapsedEventArgs e)
  5297. {
  5298. CheckHeartbeat();
  5299. IEtcdModule etcd = RequestModuleInterface<IEtcdModule>();
  5300. int flags;
  5301. string message;
  5302. if (etcd != null)
  5303. {
  5304. int health = GetHealth(out flags, out message);
  5305. if (health != m_lastHealth)
  5306. {
  5307. m_lastHealth = health;
  5308. etcd.Store("Health", health.ToString(), 300000);
  5309. etcd.Store("HealthFlags", flags.ToString(), 300000);
  5310. }
  5311. int roots = 0;
  5312. foreach (ScenePresence sp in GetScenePresences())
  5313. if (!sp.IsChildAgent && !sp.IsNPC)
  5314. roots++;
  5315. if (m_lastUsers != roots)
  5316. {
  5317. m_lastUsers = roots;
  5318. etcd.Store("RootAgents", roots.ToString(), 300000);
  5319. }
  5320. }
  5321. }
  5322. /// This method deals with movement when an avatar is automatically moving (but this is distinct from the
  5323. /// autopilot that moves an avatar to a sit target!.
  5324. /// </summary>
  5325. /// <remarks>
  5326. /// This is not intended as a permament location for this method.
  5327. /// </remarks>
  5328. /// <param name="presence"></param>
  5329. /* move to target is now done on presence update
  5330. private void HandleOnSignificantClientMovement(ScenePresence presence)
  5331. {
  5332. if (presence.MovingToTarget)
  5333. {
  5334. double distanceToTarget = Util.GetDistanceTo(presence.AbsolutePosition, presence.MoveToPositionTarget);
  5335. // m_log.DebugFormat(
  5336. // "[SCENE]: Abs pos of {0} is {1}, target {2}, distance {3}",
  5337. // presence.Name, presence.AbsolutePosition, presence.MoveToPositionTarget, distanceToTarget);
  5338. // Check the error term of the current position in relation to the target position
  5339. if (distanceToTarget <= ScenePresence.SIGNIFICANT_MOVEMENT)
  5340. {
  5341. // We are close enough to the target
  5342. // m_log.DebugFormat("[SCENEE]: Stopping autopilot of {0}", presence.Name);
  5343. presence.Velocity = Vector3.Zero;
  5344. presence.AbsolutePosition = presence.MoveToPositionTarget;
  5345. presence.ResetMoveToTarget();
  5346. if (presence.Flying)
  5347. {
  5348. // A horrible hack to stop the avatar dead in its tracks rather than having them overshoot
  5349. // the target if flying.
  5350. // We really need to be more subtle (slow the avatar as it approaches the target) or at
  5351. // least be able to set collision status once, rather than 5 times to give it enough
  5352. // weighting so that that PhysicsActor thinks it really is colliding.
  5353. for (int i = 0; i < 5; i++)
  5354. presence.IsColliding = true;
  5355. if (presence.LandAtTarget)
  5356. presence.Flying = false;
  5357. // Vector3 targetPos = presence.MoveToPositionTarget;
  5358. // float terrainHeight = (float)presence.Scene.Heightmap[(int)targetPos.X, (int)targetPos.Y];
  5359. // if (targetPos.Z - terrainHeight < 0.2)
  5360. // {
  5361. // presence.Flying = false;
  5362. // }
  5363. }
  5364. // m_log.DebugFormat(
  5365. // "[SCENE]: AgentControlFlags {0}, MovementFlag {1} for {2}",
  5366. // presence.AgentControlFlags, presence.MovementFlag, presence.Name);
  5367. }
  5368. else
  5369. {
  5370. // m_log.DebugFormat(
  5371. // "[SCENE]: Updating npc {0} at {1} for next movement to {2}",
  5372. // presence.Name, presence.AbsolutePosition, presence.MoveToPositionTarget);
  5373. Vector3 agent_control_v3 = new Vector3();
  5374. presence.HandleMoveToTargetUpdate(1, ref agent_control_v3);
  5375. presence.AddNewMovement(agent_control_v3);
  5376. }
  5377. }
  5378. }
  5379. */
  5380. // manage and select spawn points in sequence
  5381. public int SpawnPoint()
  5382. {
  5383. int spawnpoints = RegionInfo.RegionSettings.SpawnPoints().Count;
  5384. if (spawnpoints == 0)
  5385. return 0;
  5386. m_SpawnPoint++;
  5387. if (m_SpawnPoint > spawnpoints)
  5388. m_SpawnPoint = 1;
  5389. return m_SpawnPoint - 1;
  5390. }
  5391. private void HandleGcCollect(string module, string[] args)
  5392. {
  5393. GC.Collect();
  5394. }
  5395. /// <summary>
  5396. /// Wrappers to get physics modules retrieve assets.
  5397. /// </summary>
  5398. /// <remarks>
  5399. /// Has to be done this way
  5400. /// because we can't assign the asset service to physics directly - at the
  5401. /// time physics are instantiated it's not registered but it will be by
  5402. /// the time the first prim exists.
  5403. /// </remarks>
  5404. /// <param name="assetID"></param>
  5405. /// <param name="callback"></param>
  5406. public void PhysicsRequestAsset(UUID assetID, AssetReceivedDelegate callback)
  5407. {
  5408. AssetService.Get(assetID.ToString(), callback, PhysicsAssetReceived);
  5409. }
  5410. private void PhysicsAssetReceived(string id, Object sender, AssetBase asset)
  5411. {
  5412. AssetReceivedDelegate callback = (AssetReceivedDelegate)sender;
  5413. callback(asset);
  5414. }
  5415. public string GetExtraSetting(string name)
  5416. {
  5417. if (m_extraSettings == null)
  5418. return String.Empty;
  5419. string val;
  5420. if (!m_extraSettings.TryGetValue(name, out val))
  5421. return String.Empty;
  5422. return val;
  5423. }
  5424. public void StoreExtraSetting(string name, string val)
  5425. {
  5426. if (m_extraSettings == null)
  5427. return;
  5428. string oldVal;
  5429. if (m_extraSettings.TryGetValue(name, out oldVal))
  5430. {
  5431. if (oldVal == val)
  5432. return;
  5433. }
  5434. m_extraSettings[name] = val;
  5435. m_SimulationDataService.SaveExtra(RegionInfo.RegionID, name, val);
  5436. m_eventManager.TriggerExtraSettingChanged(this, name, val);
  5437. }
  5438. public void RemoveExtraSetting(string name)
  5439. {
  5440. if (m_extraSettings == null)
  5441. return;
  5442. if (!m_extraSettings.ContainsKey(name))
  5443. return;
  5444. m_extraSettings.Remove(name);
  5445. m_SimulationDataService.RemoveExtra(RegionInfo.RegionID, name);
  5446. m_eventManager.TriggerExtraSettingChanged(this, name, String.Empty);
  5447. }
  5448. public bool InTeleportTargetsCoolDown(UUID sourceID, UUID targetID, double timeout)
  5449. {
  5450. lock(TeleportTargetsCoolDown)
  5451. {
  5452. UUID lastSource = UUID.Zero;
  5453. TeleportTargetsCoolDown.TryGetValue(targetID, out lastSource);
  5454. if(lastSource == UUID.Zero)
  5455. {
  5456. TeleportTargetsCoolDown.Add(targetID, sourceID, timeout);
  5457. return false;
  5458. }
  5459. TeleportTargetsCoolDown.AddOrUpdate(targetID, sourceID, timeout);
  5460. return lastSource == sourceID;
  5461. }
  5462. }
  5463. }
  5464. }