Scene.cs 258 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411641264136414641564166417641864196420642164226423642464256426642764286429643064316432643364346435643664376438
  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. m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
  791. if (RegionInfo.NonphysPrimMax > 0)
  792. {
  793. m_maxNonphys = RegionInfo.NonphysPrimMax;
  794. }
  795. m_minPhys = startupConfig.GetFloat("PhysicalPrimMin", m_minPhys);
  796. if (RegionInfo.PhysPrimMin > 0)
  797. {
  798. m_minPhys = RegionInfo.PhysPrimMin;
  799. }
  800. m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);
  801. if (RegionInfo.PhysPrimMax > 0)
  802. {
  803. m_maxPhys = RegionInfo.PhysPrimMax;
  804. }
  805. m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
  806. if (RegionInfo.LinksetCapacity > 0)
  807. {
  808. m_linksetCapacity = RegionInfo.LinksetCapacity;
  809. }
  810. m_linksetPhysCapacity = startupConfig.GetInt("LinksetPhysPrims", m_linksetPhysCapacity);
  811. SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
  812. TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
  813. // Here, if clamping is requested in either global or
  814. // local config, it will be used
  815. //
  816. m_clampPrimSize = startupConfig.GetBoolean("ClampPrimSize", m_clampPrimSize);
  817. if (RegionInfo.ClampPrimSize)
  818. {
  819. m_clampPrimSize = true;
  820. }
  821. m_clampNegativeZ = startupConfig.GetBoolean("ClampNegativeZ", m_clampNegativeZ);
  822. m_useTrashOnDelete = startupConfig.GetBoolean("UseTrashOnDelete",m_useTrashOnDelete);
  823. m_trustBinaries = startupConfig.GetBoolean("TrustBinaries", m_trustBinaries);
  824. m_allowScriptCrossings = startupConfig.GetBoolean("AllowScriptCrossing", m_allowScriptCrossings);
  825. m_dontPersistBefore =
  826. startupConfig.GetLong("MinimumTimeBeforePersistenceConsidered", DEFAULT_MIN_TIME_FOR_PERSISTENCE);
  827. m_dontPersistBefore *= 10000000;
  828. m_persistAfter =
  829. startupConfig.GetLong("MaximumTimeBeforePersistenceConsidered", DEFAULT_MAX_TIME_FOR_PERSISTENCE);
  830. m_persistAfter *= 10000000;
  831. m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
  832. m_log.InfoFormat("[SCENE]: Default script engine {0}", m_defaultScriptEngine);
  833. m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl);
  834. m_seeIntoBannedRegion = startupConfig.GetBoolean("SeeIntoBannedRegion", m_seeIntoBannedRegion);
  835. string[] possibleMapConfigSections = new string[] { "Map", "Startup" };
  836. m_generateMaptiles
  837. = Util.GetConfigVarFromSections<bool>(config, "GenerateMaptiles", possibleMapConfigSections, true);
  838. if (m_generateMaptiles)
  839. {
  840. int maptileRefresh = Util.GetConfigVarFromSections<int>(config, "MaptileRefresh", possibleMapConfigSections, 0);
  841. m_log.InfoFormat("[SCENE]: Region {0}, WORLD MAP refresh time set to {1} seconds", RegionInfo.RegionName, maptileRefresh);
  842. if (maptileRefresh != 0)
  843. {
  844. m_mapGenerationTimer.Interval = maptileRefresh * 1000;
  845. m_mapGenerationTimer.Elapsed += RegenerateMaptileAndReregister;
  846. m_mapGenerationTimer.AutoReset = true;
  847. m_mapGenerationTimer.Start();
  848. }
  849. }
  850. else
  851. {
  852. string tile
  853. = Util.GetConfigVarFromSections<string>(
  854. config, "MaptileStaticUUID", possibleMapConfigSections, UUID.Zero.ToString());
  855. UUID tileID;
  856. if (tile != UUID.Zero.ToString() && UUID.TryParse(tile, out tileID))
  857. {
  858. RegionInfo.RegionSettings.TerrainImageID = tileID;
  859. }
  860. else
  861. {
  862. RegionInfo.RegionSettings.TerrainImageID = RegionInfo.MaptileStaticUUID;
  863. m_log.InfoFormat("[SCENE]: Region {0}, maptile set to {1}", RegionInfo.RegionName, RegionInfo.MaptileStaticUUID.ToString());
  864. }
  865. }
  866. string[] possibleAccessControlConfigSections = new string[] { "Startup", "AccessControl"};
  867. string grant
  868. = Util.GetConfigVarFromSections<string>(
  869. config, "AllowedClients", possibleAccessControlConfigSections, string.Empty);
  870. if (grant.Length > 0)
  871. {
  872. foreach (string viewer in grant.Split(','))
  873. {
  874. m_AllowedViewers.Add(viewer.Trim().ToLower());
  875. }
  876. }
  877. grant
  878. = Util.GetConfigVarFromSections<string>(
  879. config, "DeniedClients", possibleAccessControlConfigSections, String.Empty);
  880. // Deal with the mess of someone having used a different word at some point
  881. if (grant == String.Empty)
  882. grant = Util.GetConfigVarFromSections<string>(
  883. config, "BannedClients", possibleAccessControlConfigSections, String.Empty);
  884. if (grant.Length > 0)
  885. {
  886. foreach (string viewer in grant.Split(','))
  887. {
  888. m_BannedViewers.Add(viewer.Trim().ToLower());
  889. }
  890. }
  891. FrameTime = startupConfig.GetFloat( "FrameTime", FrameTime);
  892. FrameTimeWarnPercent = startupConfig.GetInt( "FrameTimeWarnPercent", FrameTimeWarnPercent);
  893. FrameTimeCritPercent = startupConfig.GetInt( "FrameTimeCritPercent", FrameTimeCritPercent);
  894. Normalized55FPS = startupConfig.GetBoolean( "Normalized55FPS", Normalized55FPS);
  895. m_update_backup = startupConfig.GetInt("UpdateStorageEveryNFrames", m_update_backup);
  896. m_update_coarse_locations = startupConfig.GetInt("UpdateCoarseLocationsEveryNFrames", m_update_coarse_locations);
  897. m_update_entitymovement = startupConfig.GetInt("UpdateEntityMovementEveryNFrames", m_update_entitymovement);
  898. m_update_events = startupConfig.GetInt("UpdateEventsEveryNFrames", m_update_events);
  899. m_update_objects = startupConfig.GetInt("UpdateObjectsEveryNFrames", m_update_objects);
  900. m_update_physics = startupConfig.GetInt("UpdatePhysicsEveryNFrames", m_update_physics);
  901. m_update_presences = startupConfig.GetInt("UpdateAgentsEveryNFrames", m_update_presences);
  902. m_update_terrain = startupConfig.GetInt("UpdateTerrainEveryNFrames", m_update_terrain);
  903. m_update_temp_cleaning = startupConfig.GetInt("UpdateTempCleaningEveryNSeconds", m_update_temp_cleaning);
  904. }
  905. #endregion Region Config
  906. IConfig entityTransferConfig = m_config.Configs["EntityTransfer"];
  907. if (entityTransferConfig != null)
  908. {
  909. AllowAvatarCrossing = entityTransferConfig.GetBoolean("AllowAvatarCrossing", AllowAvatarCrossing);
  910. DisableObjectTransfer = entityTransferConfig.GetBoolean("DisableObjectTransfer", false);
  911. }
  912. #region Interest Management
  913. IConfig interestConfig = m_config.Configs["InterestManagement"];
  914. if (interestConfig != null)
  915. {
  916. string update_prioritization_scheme = interestConfig.GetString("UpdatePrioritizationScheme", "Time").Trim().ToLower();
  917. try
  918. {
  919. UpdatePrioritizationScheme = (UpdatePrioritizationSchemes)Enum.Parse(typeof(UpdatePrioritizationSchemes), update_prioritization_scheme, true);
  920. }
  921. catch (Exception)
  922. {
  923. m_log.Warn("[PRIORITIZER]: UpdatePrioritizationScheme was not recognized, setting to default prioritizer Time");
  924. UpdatePrioritizationScheme = UpdatePrioritizationSchemes.Time;
  925. }
  926. IsReprioritizationEnabled
  927. = interestConfig.GetBoolean("ReprioritizationEnabled", IsReprioritizationEnabled);
  928. ReprioritizationInterval
  929. = interestConfig.GetFloat("ReprioritizationInterval", ReprioritizationInterval);
  930. ReprioritizationDistance
  931. = interestConfig.GetFloat("RootReprioritizationDistance", ReprioritizationDistance);
  932. if(ReprioritizationDistance < m_minReprioritizationDistance)
  933. ReprioritizationDistance = m_minReprioritizationDistance;
  934. ObjectsCullingByDistance
  935. = interestConfig.GetBoolean("ObjectsCullingByDistance", ObjectsCullingByDistance);
  936. }
  937. m_log.DebugFormat("[SCENE]: Using the {0} prioritization scheme", UpdatePrioritizationScheme);
  938. #endregion Interest Management
  939. StatsReporter = new SimStatsReporter(this);
  940. StatsReporter.OnSendStatsResult += SendSimStatsPackets;
  941. StatsReporter.OnStatsIncorrect += m_sceneGraph.RecalculateStats;
  942. IConfig restartConfig = config.Configs["RestartModule"];
  943. if (restartConfig != null)
  944. {
  945. string markerPath = restartConfig.GetString("MarkerPath", String.Empty);
  946. if (markerPath != String.Empty)
  947. {
  948. string path = Path.Combine(markerPath, RegionInfo.RegionID.ToString() + ".started");
  949. try
  950. {
  951. string pidstring = System.Diagnostics.Process.GetCurrentProcess().Id.ToString();
  952. FileStream fs = File.Create(path);
  953. System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
  954. Byte[] buf = enc.GetBytes(pidstring);
  955. fs.Write(buf, 0, buf.Length);
  956. fs.Close();
  957. }
  958. catch (Exception)
  959. {
  960. }
  961. }
  962. }
  963. StartTimerWatchdog();
  964. }
  965. public Scene(RegionInfo regInfo)
  966. : base(regInfo)
  967. {
  968. m_sceneGraph = new SceneGraph(this);
  969. // If the scene graph has an Unrecoverable error, restart this sim.
  970. // Currently the only thing that causes it to happen is two kinds of specific
  971. // Physics based crashes.
  972. //
  973. // Out of memory
  974. // Operating system has killed the plugin
  975. m_sceneGraph.UnRecoverableError
  976. += () =>
  977. {
  978. m_log.ErrorFormat("[SCENE]: Restarting region {0} due to unrecoverable physics crash", Name);
  979. RestartNow();
  980. };
  981. PhysicalPrims = true;
  982. CollidablePrims = true;
  983. PhysicsEnabled = true;
  984. AllowAvatarCrossing = true;
  985. PeriodicBackup = true;
  986. UseBackup = true;
  987. IsReprioritizationEnabled = true;
  988. UpdatePrioritizationScheme = UpdatePrioritizationSchemes.Time;
  989. ReprioritizationInterval = 5000;
  990. ReprioritizationDistance = m_minReprioritizationDistance;
  991. m_eventManager = new EventManager();
  992. m_permissions = new ScenePermissions(this);
  993. }
  994. #endregion
  995. #region Startup / Close Methods
  996. /// <value>
  997. /// The scene graph for this scene
  998. /// </value>
  999. /// TODO: Possibly stop other classes being able to manipulate this directly.
  1000. public SceneGraph SceneGraph
  1001. {
  1002. get { return m_sceneGraph; }
  1003. }
  1004. /// <summary>
  1005. /// Called by the module loader when all modules are loaded, after each module's
  1006. /// RegionLoaded hook is called. This is the earliest time where RequestModuleInterface
  1007. /// may be used.
  1008. /// </summary>
  1009. public void AllModulesLoaded()
  1010. {
  1011. IDialogModule dm = RequestModuleInterface<IDialogModule>();
  1012. if (dm != null)
  1013. m_eventManager.OnPermissionError += dm.SendAlertToUser;
  1014. ISimulatorFeaturesModule fm = RequestModuleInterface<ISimulatorFeaturesModule>();
  1015. if (fm != null)
  1016. {
  1017. OSD openSimExtras;
  1018. OSDMap openSimExtrasMap;
  1019. if (!fm.TryGetFeature("OpenSimExtras", out openSimExtras))
  1020. openSimExtras = new OSDMap();
  1021. float statisticsFPSfactor = 1.0f;
  1022. if(Normalized55FPS)
  1023. statisticsFPSfactor = 55.0f * FrameTime;
  1024. openSimExtrasMap = (OSDMap)openSimExtras;
  1025. openSimExtrasMap["SimulatorFPS"] = OSD.FromReal(1.0f / FrameTime);
  1026. openSimExtrasMap["SimulatorFPSFactor"] = OSD.FromReal(statisticsFPSfactor);
  1027. openSimExtrasMap["SimulatorFPSWarnPercent"] = OSD.FromInteger(FrameTimeWarnPercent);
  1028. openSimExtrasMap["SimulatorFPSCritPercent"] = OSD.FromInteger(FrameTimeCritPercent);
  1029. fm.AddFeature("OpenSimExtras", openSimExtrasMap);
  1030. }
  1031. }
  1032. protected virtual void RegisterDefaultSceneEvents()
  1033. {
  1034. // m_eventManager.OnSignificantClientMovement += HandleOnSignificantClientMovement;
  1035. }
  1036. public override string GetSimulatorVersion()
  1037. {
  1038. return m_simulatorVersion;
  1039. }
  1040. /// <summary>
  1041. /// Process the fact that a neighbouring region has come up.
  1042. /// </summary>
  1043. /// <remarks>
  1044. /// We only add it to the neighbor list if it's within 1 region from here.
  1045. /// Agents may have draw distance values that cross two regions though, so
  1046. /// we add it to the notify list regardless of distance. We'll check
  1047. /// the agent's draw distance before notifying them though.
  1048. /// </remarks>
  1049. /// <param name="otherRegion">RegionInfo handle for the new region.</param>
  1050. /// <returns>True after all operations complete, throws exceptions otherwise.</returns>
  1051. public override void OtherRegionUp(GridRegion otherRegion)
  1052. {
  1053. if (RegionInfo.RegionHandle != otherRegion.RegionHandle)
  1054. {
  1055. if (isNeighborRegion(otherRegion))
  1056. {
  1057. // Let the grid service module know, so this can be cached
  1058. m_eventManager.TriggerOnRegionUp(otherRegion);
  1059. try
  1060. {
  1061. ForEachRootScenePresence(delegate(ScenePresence agent)
  1062. {
  1063. //agent.ControllingClient.new
  1064. //this.CommsManager.InterRegion.InformRegionOfChildAgent(otherRegion.RegionHandle, agent.ControllingClient.RequestClientInfo());
  1065. List<ulong> old = new List<ulong>();
  1066. old.Add(otherRegion.RegionHandle);
  1067. agent.DropOldNeighbours(old);
  1068. if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
  1069. EntityTransferModule.EnableChildAgent(agent, otherRegion);
  1070. });
  1071. }
  1072. catch (NullReferenceException)
  1073. {
  1074. // This means that we're not booted up completely yet.
  1075. // This shouldn't happen too often anymore.
  1076. m_log.Error("[SCENE]: Couldn't inform client of regionup because we got a null reference exception");
  1077. }
  1078. }
  1079. else
  1080. {
  1081. m_log.InfoFormat(
  1082. "[SCENE]: Got notice about far away Region: {0} at ({1}, {2})",
  1083. otherRegion.RegionName, otherRegion.RegionLocX, otherRegion.RegionLocY);
  1084. }
  1085. }
  1086. }
  1087. public bool isNeighborRegion(GridRegion otherRegion)
  1088. {
  1089. int tmp = otherRegion.RegionLocX - (int)RegionInfo.WorldLocX; ;
  1090. if (tmp < -otherRegion.RegionSizeX && tmp > RegionInfo.RegionSizeX)
  1091. return false;
  1092. tmp = otherRegion.RegionLocY - (int)RegionInfo.WorldLocY;
  1093. if (tmp < -otherRegion.RegionSizeY && tmp > RegionInfo.RegionSizeY)
  1094. return false;
  1095. return true;
  1096. }
  1097. public void AddNeighborRegion(RegionInfo region)
  1098. {
  1099. lock (m_neighbours)
  1100. {
  1101. if (!CheckNeighborRegion(region))
  1102. {
  1103. m_neighbours.Add(region);
  1104. }
  1105. }
  1106. }
  1107. public bool CheckNeighborRegion(RegionInfo region)
  1108. {
  1109. bool found = false;
  1110. lock (m_neighbours)
  1111. {
  1112. foreach (RegionInfo reg in m_neighbours)
  1113. {
  1114. if (reg.RegionHandle == region.RegionHandle)
  1115. {
  1116. found = true;
  1117. break;
  1118. }
  1119. }
  1120. }
  1121. return found;
  1122. }
  1123. // Alias IncomingHelloNeighbour OtherRegionUp, for now
  1124. public GridRegion IncomingHelloNeighbour(RegionInfo neighbour)
  1125. {
  1126. OtherRegionUp(new GridRegion(neighbour));
  1127. return new GridRegion(RegionInfo);
  1128. }
  1129. // This causes the region to restart immediatley.
  1130. public void RestartNow()
  1131. {
  1132. IConfig startupConfig = m_config.Configs["Startup"];
  1133. if (startupConfig != null)
  1134. {
  1135. if (startupConfig.GetBoolean("InworldRestartShutsDown", false))
  1136. {
  1137. MainConsole.Instance.RunCommand("shutdown");
  1138. return;
  1139. }
  1140. }
  1141. m_log.InfoFormat("[REGION]: Restarting region {0}", Name);
  1142. Close();
  1143. base.Restart();
  1144. }
  1145. // This is a helper function that notifies root agents in this region that a new sim near them has come up
  1146. // This is in the form of a timer because when an instance of OpenSim.exe is started,
  1147. // Even though the sims initialize, they don't listen until 'all of the sims are initialized'
  1148. // If we tell an agent about a sim that's not listening yet, the agent will not be able to connect to it.
  1149. // subsequently the agent will never see the region come back online.
  1150. public void RestartNotifyWaitElapsed(object sender, ElapsedEventArgs e)
  1151. {
  1152. m_restartWaitTimer.Stop();
  1153. lock (m_regionRestartNotifyList)
  1154. {
  1155. foreach (RegionInfo region in m_regionRestartNotifyList)
  1156. {
  1157. GridRegion r = new GridRegion(region);
  1158. try
  1159. {
  1160. ForEachRootScenePresence(delegate(ScenePresence agent)
  1161. {
  1162. if (EntityTransferModule != null && agent.PresenceType != PresenceType.Npc)
  1163. EntityTransferModule.EnableChildAgent(agent, r);
  1164. });
  1165. }
  1166. catch (NullReferenceException)
  1167. {
  1168. // This means that we're not booted up completely yet.
  1169. // This shouldn't happen too often anymore.
  1170. }
  1171. }
  1172. // Reset list to nothing.
  1173. m_regionRestartNotifyList.Clear();
  1174. }
  1175. }
  1176. public int GetInaccurateNeighborCount()
  1177. {
  1178. return m_neighbours.Count;
  1179. }
  1180. // This is the method that shuts down the scene.
  1181. public override void Close()
  1182. {
  1183. if (m_shuttingDown)
  1184. {
  1185. m_log.WarnFormat("[SCENE]: Ignoring close request because already closing {0}", Name);
  1186. return;
  1187. }
  1188. IEtcdModule etcd = RequestModuleInterface<IEtcdModule>();
  1189. if (etcd != null)
  1190. {
  1191. etcd.Delete("Health");
  1192. etcd.Delete("HealthFlags");
  1193. etcd.Delete("RootAgents");
  1194. }
  1195. m_log.InfoFormat("[SCENE]: Closing down the single simulator: {0}", RegionInfo.RegionName);
  1196. StatsReporter.Close();
  1197. m_restartTimer.Stop();
  1198. m_restartTimer.Close();
  1199. if (!GridService.DeregisterRegion(RegionInfo.RegionID))
  1200. m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
  1201. // Kick all ROOT agents with the message, 'The simulator is going down'
  1202. ForEachScenePresence(delegate(ScenePresence avatar)
  1203. {
  1204. avatar.RemoveNeighbourRegion(RegionInfo.RegionHandle);
  1205. if (!avatar.IsChildAgent)
  1206. avatar.ControllingClient.Kick("The simulator is going down.");
  1207. avatar.ControllingClient.SendShutdownConnectionNotice();
  1208. });
  1209. // Stop updating the scene objects and agents.
  1210. m_shuttingDown = true;
  1211. // Wait here, or the kick messages won't actually get to the agents before the scene terminates.
  1212. // We also need to wait to avoid a race condition with the scene update loop which might not yet
  1213. // have checked ShuttingDown.
  1214. Thread.Sleep(500);
  1215. // Stop all client threads.
  1216. ForEachScenePresence(delegate(ScenePresence avatar) { CloseAgent(avatar.UUID, false); });
  1217. m_log.Debug("[SCENE]: TriggerSceneShuttingDown");
  1218. EventManager.TriggerSceneShuttingDown(this);
  1219. m_log.Debug("[SCENE]: Persisting changed objects");
  1220. Backup(true);
  1221. m_log.Debug("[SCENE]: Closing scene");
  1222. m_sceneGraph.Close();
  1223. base.Close();
  1224. // XEngine currently listens to the EventManager.OnShutdown event to trigger script stop and persistence.
  1225. // Therefore. we must dispose of the PhysicsScene after this to prevent a window where script code can
  1226. // attempt to reference a null or disposed physics scene.
  1227. if (PhysicsScene != null)
  1228. {
  1229. m_log.Debug("[SCENE]: Dispose Physics");
  1230. PhysicsScene phys = PhysicsScene;
  1231. // remove the physics engine from both Scene and SceneGraph
  1232. PhysicsScene = null;
  1233. phys.Dispose();
  1234. phys = null;
  1235. }
  1236. }
  1237. public override void Start()
  1238. {
  1239. Start(true);
  1240. }
  1241. /// <summary>
  1242. /// Start the scene
  1243. /// </summary>
  1244. /// <param name='startScripts'>
  1245. /// Start the scripts within the scene.
  1246. /// </param>
  1247. public void Start(bool startScripts)
  1248. {
  1249. if (IsRunning)
  1250. return;
  1251. m_isRunning = true;
  1252. m_active = true;
  1253. m_unixStartTime = Util.UnixTimeSinceEpoch();
  1254. // m_log.DebugFormat("[SCENE]: Starting Heartbeat timer for {0}", RegionInfo.RegionName);
  1255. if (m_heartbeatThread != null)
  1256. {
  1257. m_hbRestarts++;
  1258. if(m_hbRestarts > 10)
  1259. Environment.Exit(1);
  1260. m_log.ErrorFormat("[SCENE]: Restarting heartbeat thread because it hasn't reported in in region {0}", RegionInfo.RegionName);
  1261. //int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
  1262. //System.Diagnostics.Process proc = new System.Diagnostics.Process();
  1263. //proc.EnableRaisingEvents=false;
  1264. //proc.StartInfo.FileName = "/bin/kill";
  1265. //proc.StartInfo.Arguments = "-QUIT " + pid.ToString();
  1266. //proc.Start();
  1267. //proc.WaitForExit();
  1268. //Thread.Sleep(1000);
  1269. //Environment.Exit(1);
  1270. m_heartbeatThread.Abort();
  1271. Watchdog.AbortThread(m_heartbeatThread.ManagedThreadId);
  1272. m_heartbeatThread = null;
  1273. }
  1274. GC.Collect();
  1275. GC.WaitForPendingFinalizers();
  1276. GC.Collect();
  1277. // tell physics to finish building actor
  1278. m_sceneGraph.ProcessPhysicsPreSimulation();
  1279. m_heartbeatThread
  1280. = WorkManager.StartThread(
  1281. Heartbeat, string.Format("Heartbeat-({0})", RegionInfo.RegionName.Replace(" ", "_")), ThreadPriority.Normal, false, false);
  1282. StartScripts();
  1283. }
  1284. /// <summary>
  1285. /// Sets up references to modules required by the scene
  1286. /// </summary>
  1287. public void SetModuleInterfaces()
  1288. {
  1289. m_xmlrpcModule = RequestModuleInterface<IXMLRPC>();
  1290. m_worldCommModule = RequestModuleInterface<IWorldComm>();
  1291. XferManager = RequestModuleInterface<IXfer>();
  1292. m_AvatarFactory = RequestModuleInterface<IAvatarFactoryModule>();
  1293. AttachmentsModule = RequestModuleInterface<IAttachmentsModule>();
  1294. m_serialiser = RequestModuleInterface<IRegionSerialiserModule>();
  1295. m_dialogModule = RequestModuleInterface<IDialogModule>();
  1296. m_capsModule = RequestModuleInterface<ICapabilitiesModule>();
  1297. EntityTransferModule = RequestModuleInterface<IEntityTransferModule>();
  1298. m_groupsModule = RequestModuleInterface<IGroupsModule>();
  1299. AgentTransactionsModule = RequestModuleInterface<IAgentAssetTransactions>();
  1300. UserManagementModule = RequestModuleInterface<IUserManagement>();
  1301. }
  1302. #endregion
  1303. #region Update Methods
  1304. /// <summary>
  1305. /// Activate the various loops necessary to continually update the scene.
  1306. /// </summary>
  1307. private void Heartbeat()
  1308. {
  1309. m_eventManager.TriggerOnRegionStarted(this);
  1310. // The first frame can take a very long time due to physics actors being added on startup. Therefore,
  1311. // don't turn on the watchdog alarm for this thread until the second frame, in order to prevent false
  1312. // alarms for scenes with many objects.
  1313. Update(1);
  1314. Watchdog.GetCurrentThreadInfo().AlarmIfTimeout = true;
  1315. m_lastFrameTick = Util.EnvironmentTickCount();
  1316. Update(-1);
  1317. Watchdog.RemoveThread();
  1318. }
  1319. public override void Update(int frames)
  1320. {
  1321. long? endFrame = null;
  1322. if (frames >= 0)
  1323. endFrame = Frame + frames;
  1324. float physicsFPS = 0f;
  1325. float frameTimeMS = FrameTime * 1000.0f;
  1326. int previousFrameTick;
  1327. double tmpMS;
  1328. double tmpMS2;
  1329. double framestart;
  1330. float sleepMS;
  1331. float sleepError = 0;
  1332. while (!m_shuttingDown && ((endFrame == null && Active) || Frame < endFrame))
  1333. {
  1334. framestart = Util.GetTimeStampMS();
  1335. ++Frame;
  1336. // m_log.DebugFormat("[SCENE]: Processing frame {0} in {1}", Frame, RegionInfo.RegionName);
  1337. agentMS = tempOnRezMS = eventMS = backupMS = terrainMS = landMS = 0f;
  1338. try
  1339. {
  1340. EventManager.TriggerRegionHeartbeatStart(this);
  1341. // Apply taints in terrain module to terrain in physics scene
  1342. tmpMS = Util.GetTimeStampMS();
  1343. if (Frame % 4 == 0)
  1344. {
  1345. CheckTerrainUpdates();
  1346. }
  1347. if (Frame % m_update_terrain == 0)
  1348. {
  1349. UpdateTerrain();
  1350. }
  1351. tmpMS2 = Util.GetTimeStampMS();
  1352. terrainMS = (float)(tmpMS2 - tmpMS);
  1353. tmpMS = tmpMS2;
  1354. if (PhysicsEnabled && Frame % m_update_physics == 0)
  1355. m_sceneGraph.UpdatePreparePhysics();
  1356. tmpMS2 = Util.GetTimeStampMS();
  1357. physicsMS2 = (float)(tmpMS2 - tmpMS);
  1358. tmpMS = tmpMS2;
  1359. /*
  1360. // Apply any pending avatar force input to the avatar's velocity
  1361. if (Frame % m_update_entitymovement == 0)
  1362. m_sceneGraph.UpdateScenePresenceMovement();
  1363. */
  1364. if (Frame % (m_update_coarse_locations) == 0 && !m_sendingCoarseLocations)
  1365. {
  1366. m_sendingCoarseLocations = true;
  1367. WorkManager.RunInThreadPool(
  1368. delegate
  1369. {
  1370. List<Vector3> coarseLocations;
  1371. List<UUID> avatarUUIDs;
  1372. SceneGraph.GetCoarseLocations(out coarseLocations, out avatarUUIDs, 60);
  1373. // Send coarse locations to clients
  1374. ForEachScenePresence(delegate(ScenePresence presence)
  1375. {
  1376. presence.SendCoarseLocations(coarseLocations, avatarUUIDs);
  1377. });
  1378. m_sendingCoarseLocations = false;
  1379. }, null, string.Format("SendCoarseLocations ({0})", Name));
  1380. }
  1381. // Get the simulation frame time that the avatar force input
  1382. // took
  1383. tmpMS2 = Util.GetTimeStampMS();
  1384. agentMS = (float)(tmpMS2 - tmpMS);
  1385. tmpMS = tmpMS2;
  1386. // Perform the main physics update. This will do the actual work of moving objects and avatars according to their
  1387. // velocity
  1388. if (Frame % m_update_physics == 0)
  1389. {
  1390. if (PhysicsEnabled)
  1391. physicsFPS = m_sceneGraph.UpdatePhysics(FrameTime);
  1392. if (SynchronizeScene != null)
  1393. SynchronizeScene(this);
  1394. }
  1395. tmpMS2 = Util.GetTimeStampMS();
  1396. physicsMS = (float)(tmpMS2 - tmpMS);
  1397. tmpMS = tmpMS2;
  1398. // Check if any objects have reached their targets
  1399. CheckAtTargets();
  1400. // Update SceneObjectGroups that have scheduled themselves for updates
  1401. // Objects queue their updates onto all scene presences
  1402. if (Frame % m_update_objects == 0)
  1403. m_sceneGraph.UpdateObjectGroups();
  1404. // Run through all ScenePresences looking for updates
  1405. // Presence updates and queued object updates for each presence are sent to clients
  1406. if (Frame % m_update_presences == 0)
  1407. m_sceneGraph.UpdatePresences();
  1408. tmpMS2 = Util.GetTimeStampMS();
  1409. agentMS += (float)(tmpMS2 - tmpMS);
  1410. tmpMS = tmpMS2;
  1411. // Delete temp-on-rez stuff
  1412. if (Frame % m_update_temp_cleaning == 0 && !m_cleaningTemps)
  1413. {
  1414. m_cleaningTemps = true;
  1415. WorkManager.RunInThreadPool(
  1416. delegate { CleanTempObjects(); m_cleaningTemps = false; }, null, string.Format("CleanTempObjects ({0})", Name));
  1417. tmpMS2 = Util.GetTimeStampMS();
  1418. tempOnRezMS = (float)(tmpMS2 - tmpMS); // bad.. counts the FireAndForget, not CleanTempObjects
  1419. tmpMS = tmpMS2;
  1420. }
  1421. if (Frame % m_update_events == 0)
  1422. {
  1423. UpdateEvents();
  1424. tmpMS2 = Util.GetTimeStampMS();
  1425. eventMS = (float)(tmpMS2 - tmpMS);
  1426. tmpMS = tmpMS2;
  1427. }
  1428. if (PeriodicBackup && Frame % m_update_backup == 0)
  1429. {
  1430. UpdateStorageBackup();
  1431. tmpMS2 = Util.GetTimeStampMS();
  1432. backupMS = (float)(tmpMS2 - tmpMS);
  1433. tmpMS = tmpMS2;
  1434. }
  1435. //if (Frame % m_update_land == 0)
  1436. //{
  1437. // int ldMS = Util.EnvironmentTickCount();
  1438. // UpdateLand();
  1439. // landMS = Util.EnvironmentTickCountSubtract(ldMS);
  1440. //}
  1441. if (!LoginsEnabled && Frame == 20)
  1442. {
  1443. GC.Collect();
  1444. GC.WaitForPendingFinalizers();
  1445. GC.Collect();
  1446. if (!LoginLock)
  1447. {
  1448. if (!StartDisabled)
  1449. {
  1450. m_log.InfoFormat("[REGION]: Enabling logins for {0}", RegionInfo.RegionName);
  1451. LoginsEnabled = true;
  1452. }
  1453. m_sceneGridService.InformNeighborsThatRegionisUp(
  1454. RequestModuleInterface<INeighbourService>(), RegionInfo);
  1455. // Region ready should always be set
  1456. Ready = true;
  1457. }
  1458. else
  1459. {
  1460. // This handles a case of a region having no scripts for the RegionReady module
  1461. if (m_sceneGraph.GetActiveScriptsCount() == 0)
  1462. {
  1463. // In this case, we leave it to the IRegionReadyModule to enable logins
  1464. // LoginLock can currently only be set by a region module implementation.
  1465. // If somehow this hasn't been done then the quickest way to bugfix is to see the
  1466. // NullReferenceException
  1467. IRegionReadyModule rrm = RequestModuleInterface<IRegionReadyModule>();
  1468. rrm.TriggerRegionReady(this);
  1469. }
  1470. }
  1471. }
  1472. }
  1473. catch (Exception e)
  1474. {
  1475. m_log.ErrorFormat(
  1476. "[SCENE]: Failed on region {0} with exception {1}{2}",
  1477. RegionInfo.RegionName, e.Message, e.StackTrace);
  1478. }
  1479. EventManager.TriggerRegionHeartbeatEnd(this);
  1480. m_firstHeartbeat = false;
  1481. Watchdog.UpdateThread();
  1482. otherMS = tempOnRezMS + eventMS + backupMS + terrainMS + landMS;
  1483. tmpMS = Util.GetTimeStampMS();
  1484. previousFrameTick = m_lastFrameTick;
  1485. m_lastFrameTick = (int)(tmpMS + 0.5);
  1486. // estimate sleep time
  1487. tmpMS2 = tmpMS - framestart;
  1488. tmpMS2 = (double)frameTimeMS - tmpMS2 - sleepError;
  1489. // reuse frameMS as temporary
  1490. frameMS = (float)tmpMS2;
  1491. // sleep if we can
  1492. if (tmpMS2 > 0)
  1493. {
  1494. Thread.Sleep((int)(tmpMS2 + 0.5));
  1495. tmpMS2 = Util.GetTimeStampMS();
  1496. sleepMS = (float)(tmpMS2 - tmpMS);
  1497. sleepError = sleepMS - frameMS;
  1498. Util.Clamp(sleepError, 0.0f, 20f);
  1499. frameMS = (float)(tmpMS2 - framestart);
  1500. }
  1501. else
  1502. {
  1503. tmpMS2 = Util.GetTimeStampMS();
  1504. frameMS = (float)(tmpMS2 - framestart);
  1505. sleepMS = 0.0f;
  1506. sleepError = 0.0f;
  1507. }
  1508. // script time is not scene frame time, but is displayed per frame
  1509. float scriptTimeMS = GetAndResetScriptExecutionTime();
  1510. StatsReporter.AddFrameStats(TimeDilation, physicsFPS, agentMS,
  1511. physicsMS + physicsMS2, otherMS , sleepMS, frameMS, scriptTimeMS);
  1512. // if (Frame%m_update_avatars == 0)
  1513. // UpdateInWorldTime();
  1514. // Optionally warn if a frame takes double the amount of time that it should.
  1515. if (DebugUpdates
  1516. && Util.EnvironmentTickCountSubtract(
  1517. m_lastFrameTick, previousFrameTick) > (int)(FrameTime * 1000 * 2))
  1518. m_log.WarnFormat(
  1519. "[SCENE]: Frame took {0} ms (desired max {1} ms) in {2}",
  1520. Util.EnvironmentTickCountSubtract(m_lastFrameTick, previousFrameTick),
  1521. FrameTime * 1000,
  1522. RegionInfo.RegionName);
  1523. }
  1524. }
  1525. /// <summary>
  1526. /// Adds the execution time of one script to the total scripts execution time for this region.
  1527. /// </summary>
  1528. /// <param name="ticks">Elapsed Stopwatch ticks</param>
  1529. public void AddScriptExecutionTime(long ticks)
  1530. {
  1531. StatsReporter.addScriptEvents(1);
  1532. Interlocked.Add(ref m_scriptExecutionTime, ticks);
  1533. }
  1534. /// <summary>
  1535. /// Returns the total execution time of all the scripts in the region since the last call
  1536. /// (in milliseconds), and clears the value in preparation for the next call.
  1537. /// </summary>
  1538. /// <returns>Time in milliseconds</returns>
  1539. // Warning: this is now called from StatsReporter, and can't be shared
  1540. public long GetAndResetScriptExecutionTime()
  1541. {
  1542. long ticks = Interlocked.Exchange(ref m_scriptExecutionTime, 0);
  1543. return (ticks * 1000L) / Stopwatch.Frequency;
  1544. }
  1545. public void AddGroupTarget(SceneObjectGroup grp)
  1546. {
  1547. lock (m_groupsWithTargets)
  1548. m_groupsWithTargets[grp.UUID] = 0;
  1549. }
  1550. public void RemoveGroupTarget(SceneObjectGroup grp)
  1551. {
  1552. lock (m_groupsWithTargets)
  1553. m_groupsWithTargets.Remove(grp.UUID);
  1554. }
  1555. private void CheckAtTargets()
  1556. {
  1557. List<UUID> objs = null;
  1558. lock (m_groupsWithTargets)
  1559. {
  1560. if (m_groupsWithTargets.Count != 0)
  1561. objs = new List<UUID>(m_groupsWithTargets.Keys);
  1562. }
  1563. if (objs != null)
  1564. {
  1565. foreach (UUID entry in objs)
  1566. {
  1567. SceneObjectGroup grp = GetSceneObjectGroup(entry);
  1568. if (grp == null)
  1569. m_groupsWithTargets.Remove(entry);
  1570. else
  1571. grp.checkAtTargets();
  1572. }
  1573. }
  1574. }
  1575. /// <summary>
  1576. /// Send out simstats data to all clients
  1577. /// </summary>
  1578. /// <param name="stats">Stats on the Simulator's performance</param>
  1579. private void SendSimStatsPackets(SimStats stats)
  1580. {
  1581. ForEachRootClient(delegate(IClientAPI client)
  1582. {
  1583. client.SendSimStats(stats);
  1584. });
  1585. }
  1586. /// <summary>
  1587. /// Update the terrain if it needs to be updated.
  1588. /// </summary>
  1589. private void UpdateTerrain()
  1590. {
  1591. EventManager.TriggerTerrainTick();
  1592. }
  1593. private void CheckTerrainUpdates()
  1594. {
  1595. EventManager.TriggerTerrainCheckUpdates();
  1596. }
  1597. /// <summary>
  1598. /// Back up queued up changes
  1599. /// </summary>
  1600. private void UpdateStorageBackup()
  1601. {
  1602. if (!m_backingup)
  1603. {
  1604. WorkManager.RunInThreadPool(o => Backup(false), null, string.Format("BackupWorker ({0})", Name));
  1605. }
  1606. }
  1607. /// <summary>
  1608. /// Sends out the OnFrame event to the modules
  1609. /// </summary>
  1610. private void UpdateEvents()
  1611. {
  1612. m_eventManager.TriggerOnFrame();
  1613. }
  1614. /// <summary>
  1615. /// Backup the scene.
  1616. /// </summary>
  1617. /// <remarks>
  1618. /// This acts as the main method of the backup thread. In a regression test whether the backup thread is not
  1619. /// running independently this can be invoked directly.
  1620. /// </remarks>
  1621. /// <param name="forced">
  1622. /// If true, then any changes that have not yet been persisted are persisted. If false,
  1623. /// then the persistence decision is left to the backup code (in some situations, such as object persistence,
  1624. /// it's much more efficient to backup multiple changes at once rather than every single one).
  1625. /// <returns></returns>
  1626. public void Backup(bool forced)
  1627. {
  1628. lock (m_returns)
  1629. {
  1630. if(m_backingup)
  1631. {
  1632. m_log.WarnFormat("[Scene] Backup of {0} already running. New call skipped", RegionInfo.RegionName);
  1633. return;
  1634. }
  1635. m_backingup = true;
  1636. try
  1637. {
  1638. EventManager.TriggerOnBackup(SimulationDataService, forced);
  1639. if(m_returns.Count == 0)
  1640. return;
  1641. IMessageTransferModule tr = RequestModuleInterface<IMessageTransferModule>();
  1642. if (tr == null)
  1643. return;
  1644. uint unixtime = (uint)Util.UnixTimeSinceEpoch();
  1645. uint estateid = RegionInfo.EstateSettings.ParentEstateID;
  1646. Guid regionguid = RegionInfo.RegionID.Guid;
  1647. foreach (KeyValuePair<UUID, ReturnInfo> ret in m_returns)
  1648. {
  1649. GridInstantMessage msg = new GridInstantMessage();
  1650. msg.fromAgentID = Guid.Empty; // From server
  1651. msg.toAgentID = ret.Key.Guid;
  1652. msg.imSessionID = Guid.NewGuid();
  1653. msg.timestamp = unixtime;
  1654. msg.fromAgentName = "Server";
  1655. msg.dialog = 19; // Object msg
  1656. msg.fromGroup = false;
  1657. msg.offline = 1;
  1658. msg.ParentEstateID = estateid;
  1659. msg.Position = Vector3.Zero;
  1660. msg.RegionID = regionguid;
  1661. // We must fill in a null-terminated 'empty' string here since bytes[0] will crash viewer 3.
  1662. msg.binaryBucket = new Byte[1] {0};
  1663. if (ret.Value.count > 1)
  1664. 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);
  1665. else
  1666. 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);
  1667. tr.SendInstantMessage(msg, delegate(bool success) { });
  1668. }
  1669. m_returns.Clear();
  1670. }
  1671. finally
  1672. {
  1673. m_backingup = false;
  1674. }
  1675. }
  1676. }
  1677. /// <summary>
  1678. /// Synchronous force backup. For deletes and links/unlinks
  1679. /// </summary>
  1680. /// <param name="group">Object to be backed up</param>
  1681. public void ForceSceneObjectBackup(SceneObjectGroup group)
  1682. {
  1683. if (group != null)
  1684. {
  1685. group.HasGroupChanged = true;
  1686. group.ProcessBackup(SimulationDataService, true);
  1687. }
  1688. }
  1689. /// <summary>
  1690. /// Tell an agent that their object has been returned.
  1691. /// </summary>
  1692. /// <remarks>
  1693. /// The actual return is handled by the caller.
  1694. /// </remarks>
  1695. /// <param name="agentID">Avatar Unique Id</param>
  1696. /// <param name="objectName">Name of object returned</param>
  1697. /// <param name="location">Location of object returned</param>
  1698. /// <param name="reason">Reasion for object return</param>
  1699. public void AddReturn(UUID agentID, string objectName, Vector3 location, string reason)
  1700. {
  1701. lock (m_returns)
  1702. {
  1703. if (m_returns.ContainsKey(agentID))
  1704. {
  1705. ReturnInfo info = m_returns[agentID];
  1706. info.count++;
  1707. m_returns[agentID] = info;
  1708. }
  1709. else
  1710. {
  1711. ReturnInfo info = new ReturnInfo();
  1712. info.count = 1;
  1713. info.objectName = objectName;
  1714. info.location = location;
  1715. info.reason = reason;
  1716. m_returns[agentID] = info;
  1717. }
  1718. }
  1719. }
  1720. #endregion
  1721. #region Load Terrain
  1722. /// <summary>
  1723. /// Store the terrain in the persistant data store
  1724. /// </summary>
  1725. public void SaveTerrain()
  1726. {
  1727. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1728. }
  1729. /// <summary>
  1730. /// Store the terrain in the persistant data store
  1731. /// </summary>
  1732. public void SaveBakedTerrain()
  1733. {
  1734. if(Bakedmap != null)
  1735. SimulationDataService.StoreBakedTerrain(Bakedmap.GetTerrainData(), RegionInfo.RegionID);
  1736. }
  1737. public void StoreWindlightProfile(RegionLightShareData wl)
  1738. {
  1739. RegionInfo.WindlightSettings = wl;
  1740. SimulationDataService.StoreRegionWindlightSettings(wl);
  1741. m_eventManager.TriggerOnSaveNewWindlightProfile();
  1742. }
  1743. public void LoadWindlightProfile()
  1744. {
  1745. RegionInfo.WindlightSettings = SimulationDataService.LoadRegionWindlightSettings(RegionInfo.RegionID);
  1746. m_eventManager.TriggerOnSaveNewWindlightProfile();
  1747. }
  1748. /// <summary>
  1749. /// Loads the World heightmap
  1750. /// </summary>
  1751. public override void LoadWorldMap()
  1752. {
  1753. try
  1754. {
  1755. Bakedmap = null;
  1756. TerrainData map = SimulationDataService.LoadBakedTerrain(RegionInfo.RegionID, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
  1757. if (map != null)
  1758. {
  1759. Bakedmap = new TerrainChannel(map);
  1760. }
  1761. }
  1762. catch (Exception e)
  1763. {
  1764. m_log.WarnFormat(
  1765. "[TERRAIN]: Scene.cs: LoadWorldMap() baked terrain - Failed with exception {0}{1}", e.Message, e.StackTrace);
  1766. }
  1767. try
  1768. {
  1769. TerrainData map = SimulationDataService.LoadTerrain(RegionInfo.RegionID, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
  1770. if (map == null)
  1771. {
  1772. if(Bakedmap != null)
  1773. {
  1774. m_log.Warn("[TERRAIN]: terrain not found. Used stored baked terrain.");
  1775. Heightmap = Bakedmap.MakeCopy();
  1776. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1777. }
  1778. else
  1779. {
  1780. // This should be in the Terrain module, but it isn't because
  1781. // the heightmap is needed _way_ before the modules are initialized...
  1782. IConfig terrainConfig = m_config.Configs["Terrain"];
  1783. String m_InitialTerrain = "pinhead-island";
  1784. if (terrainConfig != null)
  1785. m_InitialTerrain = terrainConfig.GetString("InitialTerrain", m_InitialTerrain);
  1786. m_log.InfoFormat("[TERRAIN]: No default terrain. Generating a new terrain {0}.", m_InitialTerrain);
  1787. Heightmap = new TerrainChannel(m_InitialTerrain, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
  1788. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1789. }
  1790. }
  1791. else
  1792. {
  1793. Heightmap = new TerrainChannel(map);
  1794. }
  1795. }
  1796. catch (IOException e)
  1797. {
  1798. m_log.WarnFormat(
  1799. "[TERRAIN]: Scene.cs: LoadWorldMap() - Regenerating as failed with exception {0}{1}",
  1800. e.Message, e.StackTrace);
  1801. #pragma warning disable 0162
  1802. if ((int)Constants.RegionSize != 256)
  1803. {
  1804. Heightmap = new TerrainChannel();
  1805. SimulationDataService.StoreTerrain(Heightmap.GetTerrainData(), RegionInfo.RegionID);
  1806. }
  1807. }
  1808. catch (Exception e)
  1809. {
  1810. m_log.WarnFormat(
  1811. "[TERRAIN]: Scene.cs: LoadWorldMap() - Failed with exception {0}{1}", e.Message, e.StackTrace);
  1812. }
  1813. if(Bakedmap == null && Heightmap != null)
  1814. {
  1815. Bakedmap = Heightmap.MakeCopy();
  1816. SimulationDataService.StoreBakedTerrain(Bakedmap.GetTerrainData(), RegionInfo.RegionID);
  1817. }
  1818. }
  1819. /// <summary>
  1820. /// Register this region with a grid service
  1821. /// </summary>
  1822. /// <exception cref="System.Exception">Thrown if registration of the region itself fails.</exception>
  1823. public void RegisterRegionWithGrid()
  1824. {
  1825. m_sceneGridService.SetScene(this);
  1826. //// Unfortunately this needs to be here and it can't be async.
  1827. //// The map tile image is stored in RegionSettings, but it also needs to be
  1828. //// stored in the GridService, because that's what the world map module uses
  1829. //// to send the map image UUIDs (of other regions) to the viewer...
  1830. if (m_generateMaptiles)
  1831. RegenerateMaptile();
  1832. GridRegion region = new GridRegion(RegionInfo);
  1833. string error = GridService.RegisterRegion(RegionInfo.ScopeID, region);
  1834. // m_log.DebugFormat("[SCENE]: RegisterRegionWithGrid. name={0},id={1},loc=<{2},{3}>,size=<{4},{5}>",
  1835. // m_regionName,
  1836. // RegionInfo.RegionID,
  1837. // RegionInfo.RegionLocX, RegionInfo.RegionLocY,
  1838. // RegionInfo.RegionSizeX, RegionInfo.RegionSizeY);
  1839. if (error != String.Empty)
  1840. throw new Exception(error);
  1841. }
  1842. #endregion
  1843. #region Load Land
  1844. /// <summary>
  1845. /// Loads all Parcel data from the datastore for region identified by regionID
  1846. /// </summary>
  1847. /// <param name="regionID">Unique Identifier of the Region to load parcel data for</param>
  1848. public void loadAllLandObjectsFromStorage(UUID regionID)
  1849. {
  1850. m_log.Info("[SCENE]: Loading land objects from storage");
  1851. List<LandData> landData = SimulationDataService.LoadLandObjects(regionID);
  1852. if (LandChannel != null)
  1853. {
  1854. if (landData.Count == 0)
  1855. {
  1856. EventManager.TriggerNoticeNoLandDataFromStorage();
  1857. }
  1858. else
  1859. {
  1860. EventManager.TriggerIncomingLandDataFromStorage(landData);
  1861. }
  1862. }
  1863. else
  1864. {
  1865. m_log.Error("[SCENE]: Land Channel is not defined. Cannot load from storage!");
  1866. }
  1867. }
  1868. #endregion
  1869. #region Primitives Methods
  1870. /// <summary>
  1871. /// Loads the World's objects
  1872. /// </summary>
  1873. /// <param name="regionID"></param>
  1874. public virtual void LoadPrimsFromStorage(UUID regionID)
  1875. {
  1876. LoadingPrims = true;
  1877. m_log.Info("[SCENE]: Loading objects from datastore");
  1878. List<SceneObjectGroup> PrimsFromDB = SimulationDataService.LoadObjects(regionID);
  1879. m_log.InfoFormat("[SCENE]: Loaded {0} objects from the datastore", PrimsFromDB.Count);
  1880. foreach (SceneObjectGroup group in PrimsFromDB)
  1881. {
  1882. AddRestoredSceneObject(group, true, true);
  1883. EventManager.TriggerOnSceneObjectLoaded(group);
  1884. SceneObjectPart rootPart = group.GetPart(group.UUID);
  1885. rootPart.Flags &= ~PrimFlags.Scripted;
  1886. rootPart.TrimPermissions();
  1887. group.InvalidateDeepEffectivePerms();
  1888. // Don't do this here - it will get done later on when sculpt data is loaded.
  1889. // group.CheckSculptAndLoad();
  1890. }
  1891. LoadingPrims = false;
  1892. EventManager.TriggerPrimsLoaded(this);
  1893. }
  1894. public bool SupportsRayCastFiltered()
  1895. {
  1896. if (PhysicsScene == null)
  1897. return false;
  1898. return PhysicsScene.SupportsRaycastWorldFiltered();
  1899. }
  1900. public object RayCastFiltered(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
  1901. {
  1902. if (PhysicsScene == null)
  1903. return null;
  1904. return PhysicsScene.RaycastWorld(position, direction, length, Count, filter);
  1905. }
  1906. /// <summary>
  1907. /// Gets a new rez location based on the raycast and the size of the object that is being rezzed.
  1908. /// </summary>
  1909. /// <param name="RayStart"></param>
  1910. /// <param name="RayEnd"></param>
  1911. /// <param name="RayTargetID"></param>
  1912. /// <param name="rot"></param>
  1913. /// <param name="bypassRayCast"></param>
  1914. /// <param name="RayEndIsIntersection"></param>
  1915. /// <param name="frontFacesOnly"></param>
  1916. /// <param name="scale"></param>
  1917. /// <param name="FaceCenter"></param>
  1918. /// <returns></returns>
  1919. public Vector3 GetNewRezLocation(Vector3 RayStart, Vector3 RayEnd, UUID RayTargetID, Quaternion rot, byte bypassRayCast, byte RayEndIsIntersection, bool frontFacesOnly, Vector3 scale, bool FaceCenter)
  1920. {
  1921. Vector3 dir = RayEnd - RayStart;
  1922. float wheight = (float)RegionInfo.RegionSettings.WaterHeight;
  1923. Vector3 wpos = Vector3.Zero;
  1924. // Check for water surface intersection from above
  1925. if ((RayStart.Z > wheight) && (RayEnd.Z < wheight))
  1926. {
  1927. float ratio = (wheight - RayStart.Z) / dir.Z;
  1928. wpos.X = RayStart.X + (ratio * dir.X);
  1929. wpos.Y = RayStart.Y + (ratio * dir.Y);
  1930. wpos.Z = wheight;
  1931. }
  1932. Vector3 pos = Vector3.Zero;
  1933. if (RayEndIsIntersection != (byte)1)
  1934. {
  1935. float dist = dir.Length();
  1936. if (dist != 0)
  1937. {
  1938. Vector3 direction = dir * (1 / dist);
  1939. dist += 1.0f;
  1940. if (SupportsRayCastFiltered())
  1941. {
  1942. RayFilterFlags rayfilter = RayFilterFlags.BackFaceCull;
  1943. rayfilter |= RayFilterFlags.land;
  1944. rayfilter |= RayFilterFlags.physical;
  1945. rayfilter |= RayFilterFlags.nonphysical;
  1946. rayfilter |= RayFilterFlags.LSLPhantom; // ubODE will only see volume detectors
  1947. // get some more contacts ???
  1948. int physcount = 4;
  1949. List<ContactResult> physresults =
  1950. (List<ContactResult>)RayCastFiltered(RayStart, direction, dist, physcount, rayfilter);
  1951. if (physresults != null && physresults.Count > 0)
  1952. {
  1953. // look for terrain ?
  1954. if(RayTargetID == UUID.Zero)
  1955. {
  1956. foreach (ContactResult r in physresults)
  1957. {
  1958. if (r.ConsumerID == 0)
  1959. {
  1960. pos = r.Normal * scale;
  1961. pos *= 0.5f;
  1962. pos = r.Pos + pos;
  1963. if (wpos.Z > pos.Z) pos = wpos;
  1964. return pos;
  1965. }
  1966. }
  1967. }
  1968. else
  1969. {
  1970. foreach (ContactResult r in physresults)
  1971. {
  1972. SceneObjectPart part = GetSceneObjectPart(r.ConsumerID);
  1973. if (part == null)
  1974. continue;
  1975. if (part.UUID == RayTargetID)
  1976. {
  1977. pos = r.Normal * scale;
  1978. pos *= 0.5f;
  1979. pos = r.Pos + pos;
  1980. if (wpos.Z > pos.Z) pos = wpos;
  1981. return pos;
  1982. }
  1983. }
  1984. }
  1985. // else the first we got
  1986. pos = physresults[0].Normal * scale;
  1987. pos *= 0.5f;
  1988. pos = physresults[0].Pos + pos;
  1989. if (wpos.Z > pos.Z)
  1990. pos = wpos;
  1991. return pos;
  1992. }
  1993. }
  1994. if (RayTargetID != UUID.Zero)
  1995. {
  1996. SceneObjectPart target = GetSceneObjectPart(RayTargetID);
  1997. Ray NewRay = new Ray(RayStart, direction);
  1998. if (target != null)
  1999. {
  2000. pos = target.AbsolutePosition;
  2001. // Ray Trace against target here
  2002. EntityIntersection ei = target.TestIntersectionOBB(NewRay, Quaternion.Identity, frontFacesOnly, FaceCenter);
  2003. // Un-comment out the following line to Get Raytrace results printed to the console.
  2004. // m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
  2005. float ScaleOffset = 0.5f;
  2006. // If we hit something
  2007. if (ei.HitTF)
  2008. {
  2009. Vector3 scaleComponent = ei.AAfaceNormal;
  2010. if (scaleComponent.X != 0) ScaleOffset = scale.X;
  2011. if (scaleComponent.Y != 0) ScaleOffset = scale.Y;
  2012. if (scaleComponent.Z != 0) ScaleOffset = scale.Z;
  2013. ScaleOffset = Math.Abs(ScaleOffset);
  2014. Vector3 intersectionpoint = ei.ipoint;
  2015. Vector3 normal = ei.normal;
  2016. // Set the position to the intersection point
  2017. Vector3 offset = (normal * (ScaleOffset / 2f));
  2018. pos = (intersectionpoint + offset);
  2019. //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
  2020. //And in cases when we weren't rezzing from inventory we were re-adding the 0.25 straight after calling this method
  2021. // Un-offset the prim (it gets offset later by the consumer method)
  2022. //pos.Z -= 0.25F;
  2023. if (wpos.Z > pos.Z) pos = wpos;
  2024. return pos;
  2025. }
  2026. }
  2027. else
  2028. {
  2029. // We don't have a target here, so we're going to raytrace all the objects in the scene.
  2030. EntityIntersection ei = m_sceneGraph.GetClosestIntersectingPrim(NewRay, true, false);
  2031. // Un-comment the following line to print the raytrace results to the console.
  2032. //m_log.Info("[RAYTRACERESULTS]: Hit:" + ei.HitTF.ToString() + " Point: " + ei.ipoint.ToString() + " Normal: " + ei.normal.ToString());
  2033. if (ei.HitTF)
  2034. {
  2035. pos = new Vector3(ei.ipoint.X, ei.ipoint.Y, ei.ipoint.Z);
  2036. }
  2037. else
  2038. {
  2039. // fall back to our stupid functionality
  2040. pos = RayEnd;
  2041. }
  2042. if (wpos.Z > pos.Z) pos = wpos;
  2043. return pos;
  2044. }
  2045. }
  2046. }
  2047. }
  2048. // fall back to our stupid functionality
  2049. pos = RayEnd;
  2050. //increase height so its above the ground.
  2051. //should be getting the normal of the ground at the rez point and using that?
  2052. pos.Z += scale.Z / 2f;
  2053. // return pos;
  2054. // check against posible water intercept
  2055. if (wpos.Z > pos.Z) pos = wpos;
  2056. return pos;
  2057. }
  2058. /// <summary>
  2059. /// Create a New SceneObjectGroup/Part by raycasting
  2060. /// </summary>
  2061. /// <param name="ownerID"></param>
  2062. /// <param name="groupID"></param>
  2063. /// <param name="RayEnd"></param>
  2064. /// <param name="rot"></param>
  2065. /// <param name="shape"></param>
  2066. /// <param name="bypassRaycast"></param>
  2067. /// <param name="RayStart"></param>
  2068. /// <param name="RayTargetID"></param>
  2069. /// <param name="RayEndIsIntersection"></param>
  2070. public virtual void AddNewPrim(UUID ownerID, UUID groupID, Vector3 RayEnd, Quaternion rot, PrimitiveBaseShape shape,
  2071. byte bypassRaycast, Vector3 RayStart, UUID RayTargetID,
  2072. byte RayEndIsIntersection)
  2073. {
  2074. Vector3 pos = GetNewRezLocation(RayStart, RayEnd, RayTargetID, rot, bypassRaycast, RayEndIsIntersection, true, new Vector3(0.5f, 0.5f, 0.5f), false);
  2075. if (Permissions.CanRezObject(1, ownerID, pos))
  2076. {
  2077. // rez ON the ground, not IN the ground
  2078. // pos.Z += 0.25F; The rez point should now be correct so that its not in the ground
  2079. AddNewPrim(ownerID, groupID, pos, rot, shape);
  2080. }
  2081. else
  2082. {
  2083. IClientAPI client = null;
  2084. if (TryGetClient(ownerID, out client))
  2085. client.SendAlertMessage("You cannot create objects here.");
  2086. }
  2087. }
  2088. public virtual SceneObjectGroup AddNewPrim(
  2089. UUID ownerID, UUID groupID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape)
  2090. {
  2091. //m_log.DebugFormat(
  2092. // "[SCENE]: Scene.AddNewPrim() pcode {0} called for {1} in {2}", shape.PCode, ownerID, RegionInfo.RegionName);
  2093. SceneObjectGroup sceneObject = null;
  2094. // If an entity creator has been registered for this prim type then use that
  2095. if (m_entityCreators.ContainsKey((PCode)shape.PCode))
  2096. {
  2097. sceneObject = m_entityCreators[(PCode)shape.PCode].CreateEntity(ownerID, groupID, pos, rot, shape);
  2098. }
  2099. else
  2100. {
  2101. // Otherwise, use this default creation code;
  2102. sceneObject = new SceneObjectGroup(ownerID, pos, rot, shape);
  2103. sceneObject.SetGroup(groupID, null);
  2104. AddNewSceneObject(sceneObject, true);
  2105. if (AgentPreferencesService != null) // This will override the brave new full perm world!
  2106. {
  2107. AgentPrefs prefs = AgentPreferencesService.GetAgentPreferences(ownerID);
  2108. // Only apply user selected prefs if the user set them
  2109. if (prefs != null && prefs.PermNextOwner != 0)
  2110. {
  2111. sceneObject.RootPart.GroupMask = (uint)prefs.PermGroup;
  2112. sceneObject.RootPart.EveryoneMask = (uint)prefs.PermEveryone;
  2113. sceneObject.RootPart.NextOwnerMask = (uint)prefs.PermNextOwner;
  2114. }
  2115. }
  2116. }
  2117. if (UserManagementModule != null)
  2118. sceneObject.RootPart.CreatorIdentification = UserManagementModule.GetUserUUI(ownerID);
  2119. sceneObject.InvalidateDeepEffectivePerms();;
  2120. sceneObject.ScheduleGroupForFullUpdate();
  2121. return sceneObject;
  2122. }
  2123. /// <summary>
  2124. /// Add an object into the scene that has come from storage
  2125. /// </summary>
  2126. ///
  2127. /// <param name="sceneObject"></param>
  2128. /// <param name="attachToBackup">
  2129. /// If true, changes to the object will be reflected in its persisted data
  2130. /// If false, the persisted data will not be changed even if the object in the scene is changed
  2131. /// </param>
  2132. /// <param name="alreadyPersisted">
  2133. /// If true, we won't persist this object until it changes
  2134. /// If false, we'll persist this object immediately
  2135. /// </param>
  2136. /// <param name="sendClientUpdates">
  2137. /// If true, we send updates to the client to tell it about this object
  2138. /// If false, we leave it up to the caller to do this
  2139. /// </param>
  2140. /// <returns>
  2141. /// true if the object was added, false if an object with the same uuid was already in the scene
  2142. /// </returns>
  2143. public bool AddRestoredSceneObject(
  2144. SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
  2145. {
  2146. if (m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates))
  2147. {
  2148. sceneObject.IsDeleted = false;
  2149. EventManager.TriggerObjectAddedToScene(sceneObject);
  2150. return true;
  2151. }
  2152. return false;
  2153. }
  2154. /// <summary>
  2155. /// Add an object into the scene that has come from storage
  2156. /// </summary>
  2157. ///
  2158. /// <param name="sceneObject"></param>
  2159. /// <param name="attachToBackup">
  2160. /// If true, changes to the object will be reflected in its persisted data
  2161. /// If false, the persisted data will not be changed even if the object in the scene is changed
  2162. /// </param>
  2163. /// <param name="alreadyPersisted">
  2164. /// If true, we won't persist this object until it changes
  2165. /// If false, we'll persist this object immediately
  2166. /// </param>
  2167. /// <returns>
  2168. /// true if the object was added, false if an object with the same uuid was already in the scene
  2169. /// </returns>
  2170. public bool AddRestoredSceneObject(
  2171. SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted)
  2172. {
  2173. return AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, true);
  2174. }
  2175. /// <summary>
  2176. /// Add a newly created object to the scene. Updates are also sent to viewers.
  2177. /// </summary>
  2178. /// <param name="sceneObject"></param>
  2179. /// <param name="attachToBackup">
  2180. /// If true, the object is made persistent into the scene.
  2181. /// If false, the object will not persist over server restarts
  2182. /// </param>
  2183. /// <returns>true if the object was added. false if not</returns>
  2184. public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup)
  2185. {
  2186. return AddNewSceneObject(sceneObject, attachToBackup, true);
  2187. }
  2188. /// <summary>
  2189. /// Add a newly created object to the scene
  2190. /// </summary>
  2191. /// <param name="sceneObject"></param>
  2192. /// <param name="attachToBackup">
  2193. /// If true, the object is made persistent into the scene.
  2194. /// If false, the object will not persist over server restarts
  2195. /// </param>
  2196. /// <param name="sendClientUpdates">
  2197. /// If true, updates for the new scene object are sent to all viewers in range.
  2198. /// If false, it is left to the caller to schedule the update
  2199. /// </param>
  2200. /// <returns>true if the object was added. false if not</returns>
  2201. public bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates)
  2202. {
  2203. if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, sendClientUpdates))
  2204. {
  2205. EventManager.TriggerObjectAddedToScene(sceneObject);
  2206. return true;
  2207. }
  2208. return false;
  2209. }
  2210. /// <summary>
  2211. /// Add a newly created object to the scene.
  2212. /// </summary>
  2213. /// <remarks>
  2214. /// This method does not send updates to the client - callers need to handle this themselves.
  2215. /// </remarks>
  2216. /// <param name="sceneObject"></param>
  2217. /// <param name="attachToBackup"></param>
  2218. /// <param name="pos">Position of the object. If null then the position stored in the object is used.</param>
  2219. /// <param name="rot">Rotation of the object. If null then the rotation stored in the object is used.</param>
  2220. /// <param name="vel">Velocity of the object. This parameter only has an effect if the object is physical</param>
  2221. /// <returns></returns>
  2222. public bool AddNewSceneObject(
  2223. SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel)
  2224. {
  2225. if (m_sceneGraph.AddNewSceneObject(sceneObject, attachToBackup, pos, rot, vel))
  2226. {
  2227. EventManager.TriggerObjectAddedToScene(sceneObject);
  2228. return true;
  2229. }
  2230. return false;
  2231. }
  2232. /// <summary>
  2233. /// Delete every object from the scene. This does not include attachments worn by avatars.
  2234. /// </summary>
  2235. public void DeleteAllSceneObjects()
  2236. {
  2237. DeleteAllSceneObjects(false);
  2238. }
  2239. /// <summary>
  2240. /// Delete every object from the scene. This does not include attachments worn by avatars.
  2241. /// </summary>
  2242. public void DeleteAllSceneObjects(bool exceptNoCopy)
  2243. {
  2244. List<SceneObjectGroup> toReturn = new List<SceneObjectGroup>();
  2245. lock (Entities)
  2246. {
  2247. EntityBase[] entities = Entities.GetEntities();
  2248. foreach (EntityBase e in entities)
  2249. {
  2250. if (e is SceneObjectGroup)
  2251. {
  2252. SceneObjectGroup sog = (SceneObjectGroup)e;
  2253. if (sog != null && !sog.IsAttachment)
  2254. {
  2255. if (!exceptNoCopy || ((sog.EffectiveOwnerPerms & (uint)PermissionMask.Copy) != 0))
  2256. {
  2257. DeleteSceneObject((SceneObjectGroup)e, false);
  2258. }
  2259. else
  2260. {
  2261. toReturn.Add((SceneObjectGroup)e);
  2262. }
  2263. }
  2264. }
  2265. }
  2266. }
  2267. if (toReturn.Count > 0)
  2268. {
  2269. returnObjects(toReturn.ToArray(), null);
  2270. }
  2271. }
  2272. /// <summary>
  2273. /// Synchronously delete the given object from the scene.
  2274. /// </summary>
  2275. /// <remarks>
  2276. /// Scripts are also removed.
  2277. /// </remarks>
  2278. /// <param name="group">Object Id</param>
  2279. /// <param name="silent">Suppress broadcasting changes to other clients.</param>
  2280. public void DeleteSceneObject(SceneObjectGroup group, bool silent)
  2281. {
  2282. DeleteSceneObject(group, silent, true);
  2283. }
  2284. /// <summary>
  2285. /// Synchronously delete the given object from the scene.
  2286. /// </summary>
  2287. /// <param name="group">Object Id</param>
  2288. /// <param name="silent">Suppress broadcasting changes to other clients.</param>
  2289. /// <param name="removeScripts">If true, then scripts are removed. If false, then they are only stopped.</para>
  2290. public void DeleteSceneObject(SceneObjectGroup group, bool silent, bool removeScripts)
  2291. {
  2292. // m_log.DebugFormat("[SCENE]: Deleting scene object {0} {1}", group.Name, group.UUID);
  2293. if (removeScripts)
  2294. group.RemoveScriptInstances(true);
  2295. else
  2296. group.StopScriptInstances();
  2297. SceneObjectPart[] partList = group.Parts;
  2298. foreach (SceneObjectPart part in partList)
  2299. {
  2300. if (part.KeyframeMotion != null)
  2301. {
  2302. part.KeyframeMotion.Delete();
  2303. part.KeyframeMotion = null;
  2304. }
  2305. if (part.IsJoint() && ((part.Flags & PrimFlags.Physics) != 0))
  2306. {
  2307. PhysicsScene.RequestJointDeletion(part.Name); // FIXME: what if the name changed?
  2308. }
  2309. else if (part.PhysActor != null)
  2310. {
  2311. part.RemoveFromPhysics();
  2312. }
  2313. }
  2314. if (UnlinkSceneObject(group, false))
  2315. {
  2316. EventManager.TriggerObjectBeingRemovedFromScene(group);
  2317. EventManager.TriggerParcelPrimCountTainted();
  2318. }
  2319. group.DeleteGroupFromScene(silent);
  2320. // use this to mean also full delete
  2321. if (removeScripts)
  2322. group.Clear();
  2323. partList = null;
  2324. // m_log.DebugFormat("[SCENE]: Exit DeleteSceneObject() for {0} {1}", group.Name, group.UUID);
  2325. }
  2326. /// <summary>
  2327. /// Unlink the given object from the scene. Unlike delete, this just removes the record of the object - the
  2328. /// object itself is not destroyed.
  2329. /// </summary>
  2330. /// <param name="so">The scene object.</param>
  2331. /// <param name="softDelete">If true, only deletes from scene, but keeps the object in the database.</param>
  2332. /// <returns>true if the object was in the scene, false if it was not</returns>
  2333. public bool UnlinkSceneObject(SceneObjectGroup so, bool softDelete)
  2334. {
  2335. if (m_sceneGraph.DeleteSceneObject(so.UUID, softDelete))
  2336. {
  2337. if (!softDelete)
  2338. {
  2339. // If the group contains prims whose SceneGroupID is incorrect then force a
  2340. // database update, because RemoveObject() works by searching on the SceneGroupID.
  2341. // This is an expensive thing to do so only do it if absolutely necessary.
  2342. if (so.GroupContainsForeignPrims)
  2343. ForceSceneObjectBackup(so);
  2344. so.DetachFromBackup();
  2345. SimulationDataService.RemoveObject(so.UUID, RegionInfo.RegionID);
  2346. }
  2347. // We need to keep track of this state in case this group is still queued for further backup.
  2348. so.IsDeleted = true;
  2349. return true;
  2350. }
  2351. return false;
  2352. }
  2353. public void updateScenePartGroup(SceneObjectPart part, SceneObjectGroup grp)
  2354. {
  2355. m_sceneGraph.updateScenePartGroup(part, grp);
  2356. }
  2357. /* not in use, outdate by async method
  2358. /// <summary>
  2359. /// Move the given scene object into a new region depending on which region its absolute position has moved
  2360. /// into.
  2361. ///
  2362. /// </summary>
  2363. /// <param name="attemptedPosition">the attempted out of region position of the scene object</param>
  2364. /// <param name="grp">the scene object that we're crossing</param>
  2365. public void CrossPrimGroupIntoNewRegion(Vector3 attemptedPosition, SceneObjectGroup grp, bool silent)
  2366. {
  2367. if (grp == null)
  2368. return;
  2369. if (grp.IsDeleted)
  2370. return;
  2371. if (grp.RootPart.DIE_AT_EDGE)
  2372. {
  2373. // We remove the object here
  2374. try
  2375. {
  2376. DeleteSceneObject(grp, false);
  2377. }
  2378. catch (Exception)
  2379. {
  2380. m_log.Warn("[SCENE]: exception when trying to remove the prim that crossed the border.");
  2381. }
  2382. return;
  2383. }
  2384. if (grp.RootPart.RETURN_AT_EDGE)
  2385. {
  2386. // We remove the object here
  2387. try
  2388. {
  2389. List<SceneObjectGroup> objects = new List<SceneObjectGroup>();
  2390. objects.Add(grp);
  2391. SceneObjectGroup[] objectsArray = objects.ToArray();
  2392. returnObjects(objectsArray, UUID.Zero);
  2393. }
  2394. catch (Exception)
  2395. {
  2396. m_log.Warn("[SCENE]: exception when trying to return the prim that crossed the border.");
  2397. }
  2398. return;
  2399. }
  2400. if (EntityTransferModule != null)
  2401. EntityTransferModule.Cross(grp, attemptedPosition, silent);
  2402. }
  2403. */
  2404. // Simple test to see if a position is in the current region.
  2405. // This test is mostly used to see if a region crossing is necessary.
  2406. // Assuming the position is relative to the region so anything outside its bounds.
  2407. // Return 'true' if position inside region.
  2408. public bool PositionIsInCurrentRegion(Vector3 pos)
  2409. {
  2410. float t = pos.X;
  2411. if (t < 0 || t >= RegionInfo.RegionSizeX)
  2412. return false;
  2413. t = pos.Y;
  2414. if (t < 0 || t >= RegionInfo.RegionSizeY)
  2415. return false;
  2416. return true;
  2417. }
  2418. /// <summary>
  2419. /// Called when objects or attachments cross the border, or teleport, between regions.
  2420. /// </summary>
  2421. /// <param name="sog"></param>
  2422. /// <returns></returns>
  2423. public bool IncomingCreateObject(Vector3 newPosition, ISceneObject sog)
  2424. {
  2425. //m_log.DebugFormat(" >>> IncomingCreateObject(sog) <<< {0} deleted? {1} isAttach? {2}", ((SceneObjectGroup)sog).AbsolutePosition,
  2426. // ((SceneObjectGroup)sog).IsDeleted, ((SceneObjectGroup)sog).RootPart.IsAttachment);
  2427. SceneObjectGroup newObject;
  2428. try
  2429. {
  2430. newObject = (SceneObjectGroup)sog;
  2431. }
  2432. catch (Exception e)
  2433. {
  2434. m_log.WarnFormat("[INTERREGION]: Problem casting object, exception {0}{1}", e.Message, e.StackTrace);
  2435. return false;
  2436. }
  2437. if (!EntityTransferModule.HandleIncomingSceneObject(newObject, newPosition))
  2438. return false;
  2439. // Do this as late as possible so that listeners have full access to the incoming object
  2440. EventManager.TriggerOnIncomingSceneObject(newObject);
  2441. return true;
  2442. }
  2443. /// <summary>
  2444. /// Adds a Scene Object group to the Scene.
  2445. /// Verifies that the creator of the object is not banned from the simulator.
  2446. /// Checks if the item is an Attachment
  2447. /// </summary>
  2448. /// <param name="sceneObject"></param>
  2449. /// <returns>True if the SceneObjectGroup was added, False if it was not</returns>
  2450. public bool AddSceneObject(SceneObjectGroup sceneObject)
  2451. {
  2452. if (sceneObject.OwnerID == UUID.Zero)
  2453. {
  2454. m_log.ErrorFormat("[SCENE]: Owner ID for {0} was zero", sceneObject.UUID);
  2455. return false;
  2456. }
  2457. // If the user is banned, we won't let any of their objects
  2458. // enter. Period.
  2459. //
  2460. int flags = GetUserFlags(sceneObject.OwnerID);
  2461. if (RegionInfo.EstateSettings.IsBanned(sceneObject.OwnerID, flags))
  2462. {
  2463. m_log.InfoFormat("[INTERREGION]: Denied prim crossing for banned avatar {0}", sceneObject.OwnerID);
  2464. return false;
  2465. }
  2466. // Force allocation of new LocalId
  2467. //
  2468. SceneObjectPart[] parts = sceneObject.Parts;
  2469. for (int i = 0; i < parts.Length; i++)
  2470. parts[i].LocalId = 0;
  2471. if (sceneObject.IsAttachmentCheckFull()) // Attachment
  2472. {
  2473. sceneObject.RootPart.AddFlag(PrimFlags.TemporaryOnRez);
  2474. // sceneObject.RootPart.AddFlag(PrimFlags.Phantom);
  2475. // Don't sent a full update here because this will cause full updates to be sent twice for
  2476. // attachments on region crossings, resulting in viewer glitches.
  2477. AddRestoredSceneObject(sceneObject, false, false, false);
  2478. // Handle attachment special case
  2479. SceneObjectPart RootPrim = sceneObject.RootPart;
  2480. // Fix up attachment Parent Local ID
  2481. ScenePresence sp = GetScenePresence(sceneObject.OwnerID);
  2482. if (sp != null)
  2483. {
  2484. SceneObjectGroup grp = sceneObject;
  2485. // m_log.DebugFormat(
  2486. // "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", grp.FromItemID, grp.UUID);
  2487. // m_log.DebugFormat(
  2488. // "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, grp.AbsolutePosition);
  2489. RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
  2490. // We must currently not resume scripts at this stage since AttachmentsModule does not have the
  2491. // information that this is due to a teleport/border cross rather than an ordinary attachment.
  2492. // We currently do this in Scene.MakeRootAgent() instead.
  2493. if (AttachmentsModule != null)
  2494. AttachmentsModule.AttachObject(sp, grp, 0, false, false, true);
  2495. }
  2496. else
  2497. {
  2498. m_log.DebugFormat("[SCENE]: Attachment {0} arrived and scene presence was not found, setting to temp", sceneObject.UUID);
  2499. // RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
  2500. // RootPrim.AddFlag(PrimFlags.TemporaryOnRez);
  2501. }
  2502. if (sceneObject.OwnerID == UUID.Zero)
  2503. {
  2504. m_log.ErrorFormat("[SCENE]: Owner ID for {0} was zero after attachment processing. BUG!", sceneObject.UUID);
  2505. return false;
  2506. }
  2507. }
  2508. else
  2509. {
  2510. if (sceneObject.OwnerID == UUID.Zero)
  2511. {
  2512. m_log.ErrorFormat("[SCENE]: Owner ID for non-attachment {0} was zero", sceneObject.UUID);
  2513. return false;
  2514. }
  2515. AddRestoredSceneObject(sceneObject, true, false);
  2516. }
  2517. return true;
  2518. }
  2519. private int GetStateSource(SceneObjectGroup sog)
  2520. {
  2521. if(!sog.IsAttachmentCheckFull())
  2522. return 2; // StateSource.PrimCrossing
  2523. ScenePresence sp = GetScenePresence(sog.OwnerID);
  2524. if (sp != null)
  2525. return sp.GetStateSource();
  2526. return 2; // StateSource.PrimCrossing
  2527. }
  2528. public int GetUserFlags(UUID user)
  2529. {
  2530. //Unfortunately the SP approach means that the value is cached until region is restarted
  2531. /*
  2532. ScenePresence sp;
  2533. if (TryGetScenePresence(user, out sp))
  2534. {
  2535. return sp.UserFlags;
  2536. }
  2537. else
  2538. {
  2539. */
  2540. UserAccount uac = UserAccountService.GetUserAccount(RegionInfo.ScopeID, user);
  2541. if (uac == null)
  2542. return 0;
  2543. return uac.UserFlags;
  2544. //}
  2545. }
  2546. #endregion
  2547. #region Add/Remove Avatar Methods
  2548. public override ISceneAgent AddNewAgent(IClientAPI client, PresenceType type)
  2549. {
  2550. ScenePresence sp;
  2551. bool vialogin;
  2552. bool reallyNew = true;
  2553. // Update the number of users attempting to login
  2554. StatsReporter.UpdateUsersLoggingIn(true);
  2555. // Validation occurs in LLUDPServer
  2556. //
  2557. // XXX: A race condition exists here where two simultaneous calls to AddNewAgent can interfere with
  2558. // each other. In practice, this does not currently occur in the code.
  2559. AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
  2560. // We lock here on AgentCircuitData to prevent a race condition between the thread adding a new connection
  2561. // and a simultaneous one that removes it (as can happen if the client is closed at a particular point
  2562. // whilst connecting).
  2563. //
  2564. // It would be easier to lock across all NewUserConnection(), AddNewAgent() and
  2565. // RemoveClient() calls for all agents, but this would allow a slow call (e.g. because of slow service
  2566. // response in some module listening to AddNewAgent()) from holding up unrelated agent calls.
  2567. //
  2568. // In practice, the lock (this) in LLUDPServer.AddNewClient() currently lock across all
  2569. // AddNewClient() operations (though not other ops).
  2570. // In the future this can be relieved once locking per agent (not necessarily on AgentCircuitData) is improved.
  2571. lock (aCircuit)
  2572. {
  2573. vialogin
  2574. = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
  2575. || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
  2576. CheckHeartbeat();
  2577. sp = GetScenePresence(client.AgentId);
  2578. if (sp == null)
  2579. {
  2580. m_log.DebugFormat(
  2581. "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}, tpflags: {4}",
  2582. client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos,
  2583. ((TPFlags)aCircuit.teleportFlags).ToString());
  2584. m_clientManager.Add(client);
  2585. SubscribeToClientEvents(client);
  2586. sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
  2587. sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
  2588. m_eventManager.TriggerOnNewPresence(sp);
  2589. }
  2590. else
  2591. {
  2592. // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
  2593. // client is for a root or child agent.
  2594. // XXX: This may be better set for a new client before that client is added to the client manager.
  2595. // But need to know what happens in the case where a ScenePresence is already present (and if this
  2596. // actually occurs).
  2597. m_log.WarnFormat(
  2598. "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
  2599. sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
  2600. reallyNew = false;
  2601. }
  2602. client.SceneAgent = sp;
  2603. // This is currently also being done earlier in NewUserConnection for real users to see if this
  2604. // resolves problems where HG agents are occasionally seen by others as "Unknown user" in chat and other
  2605. // places. However, we still need to do it here for NPCs.
  2606. CacheUserName(sp, aCircuit);
  2607. if (reallyNew)
  2608. EventManager.TriggerOnNewClient(client);
  2609. if (vialogin)
  2610. EventManager.TriggerOnClientLogin(client);
  2611. }
  2612. // User has logged into the scene so update the list of users logging
  2613. // in
  2614. StatsReporter.UpdateUsersLoggingIn(false);
  2615. m_LastLogin = Util.EnvironmentTickCount();
  2616. return sp;
  2617. }
  2618. /// <summary>
  2619. /// Returns the Home URI of the agent, or null if unknown.
  2620. /// </summary>
  2621. public string GetAgentHomeURI(UUID agentID)
  2622. {
  2623. AgentCircuitData circuit = AuthenticateHandler.GetAgentCircuitData(agentID);
  2624. if (circuit != null && circuit.ServiceURLs != null && circuit.ServiceURLs.ContainsKey("HomeURI"))
  2625. return circuit.ServiceURLs["HomeURI"].ToString();
  2626. else
  2627. return null;
  2628. }
  2629. /// <summary>
  2630. /// Cache the user name for later use.
  2631. /// </summary>
  2632. /// <param name="sp"></param>
  2633. /// <param name="aCircuit"></param>
  2634. private void CacheUserName(ScenePresence sp, AgentCircuitData aCircuit)
  2635. {
  2636. if (UserManagementModule != null)
  2637. {
  2638. string first = aCircuit.firstname, last = aCircuit.lastname;
  2639. if (sp != null && sp.PresenceType == PresenceType.Npc)
  2640. {
  2641. UserManagementModule.AddUser(aCircuit.AgentID, first, last, true);
  2642. }
  2643. else
  2644. {
  2645. string homeURL = string.Empty;
  2646. if (aCircuit.ServiceURLs.ContainsKey("HomeURI"))
  2647. homeURL = aCircuit.ServiceURLs["HomeURI"].ToString();
  2648. if (aCircuit.lastname.StartsWith("@"))
  2649. {
  2650. string[] parts = aCircuit.firstname.Split('.');
  2651. if (parts.Length >= 2)
  2652. {
  2653. first = parts[0];
  2654. last = parts[1];
  2655. }
  2656. }
  2657. UserManagementModule.AddUser(aCircuit.AgentID, first, last, homeURL);
  2658. }
  2659. }
  2660. }
  2661. private bool VerifyClient(AgentCircuitData aCircuit, System.Net.IPEndPoint ep, out bool vialogin)
  2662. {
  2663. vialogin = false;
  2664. // Do the verification here
  2665. if ((aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0)
  2666. {
  2667. m_log.DebugFormat("[SCENE]: Incoming client {0} {1} in region {2} via HG login", aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2668. vialogin = true;
  2669. IUserAgentVerificationModule userVerification = RequestModuleInterface<IUserAgentVerificationModule>();
  2670. if (userVerification != null && ep != null)
  2671. {
  2672. if (!userVerification.VerifyClient(aCircuit, ep.Address.ToString()))
  2673. {
  2674. // uh-oh, this is fishy
  2675. m_log.DebugFormat("[SCENE]: User Client Verification for {0} {1} in {2} returned false", aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2676. return false;
  2677. }
  2678. else
  2679. m_log.DebugFormat("[SCENE]: User Client Verification for {0} {1} in {2} returned true", aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2680. }
  2681. }
  2682. else if ((aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0)
  2683. {
  2684. m_log.DebugFormat("[SCENE]: Incoming client {0} {1} in region {2} via regular login. Client IP verification not performed.",
  2685. aCircuit.firstname, aCircuit.lastname, RegionInfo.RegionName);
  2686. vialogin = true;
  2687. }
  2688. return true;
  2689. }
  2690. // Called by Caps, on the first HTTP contact from the client
  2691. public override bool CheckClient(UUID agentID, System.Net.IPEndPoint ep)
  2692. {
  2693. AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(agentID);
  2694. if (aCircuit != null)
  2695. {
  2696. bool vialogin = false;
  2697. if (!VerifyClient(aCircuit, ep, out vialogin))
  2698. {
  2699. // if it doesn't pass, we remove the agentcircuitdata altogether
  2700. // and the scene presence and the client, if they exist
  2701. try
  2702. {
  2703. ScenePresence sp = WaitGetScenePresence(agentID);
  2704. if (sp != null)
  2705. {
  2706. PresenceService.LogoutAgent(sp.ControllingClient.SessionId);
  2707. CloseAgent(sp.UUID, false);
  2708. }
  2709. // BANG! SLASH!
  2710. m_authenticateHandler.RemoveCircuit(agentID);
  2711. return false;
  2712. }
  2713. catch (Exception e)
  2714. {
  2715. m_log.DebugFormat("[SCENE]: Exception while closing aborted client: {0}", e.StackTrace);
  2716. }
  2717. }
  2718. else
  2719. return true;
  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. // We have to wait until the viewer contacts this region after receiving EAC.
  3841. // That calls AddNewClient, which finally creates the ScenePresence
  3842. int flags = GetUserFlags(cAgentData.AgentID);
  3843. if (RegionInfo.EstateSettings.IsBanned(cAgentData.AgentID, flags))
  3844. {
  3845. m_log.DebugFormat("[SCENE]: Denying root agent entry to {0}: banned", cAgentData.AgentID);
  3846. return false;
  3847. }
  3848. // TODO: This check should probably be in QueryAccess().
  3849. ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID,
  3850. (float)RegionInfo.RegionSizeX * 0.5f, (float)RegionInfo.RegionSizeY * 0.5f);
  3851. if (nearestParcel == null)
  3852. {
  3853. m_log.InfoFormat(
  3854. "[SCENE]: Denying root agent entry to {0} in {1}: no allowed parcel",
  3855. cAgentData.AgentID, RegionInfo.RegionName);
  3856. return false;
  3857. }
  3858. // We have to wait until the viewer contacts this region
  3859. // after receiving the EnableSimulator HTTP Event Queue message (for the v1 teleport protocol)
  3860. // or TeleportFinish (for the v2 teleport protocol). This triggers the viewer to send
  3861. // a UseCircuitCode packet which in turn calls AddNewAgent which finally creates the ScenePresence.
  3862. ScenePresence sp = WaitGetScenePresence(cAgentData.AgentID);
  3863. if (sp != null)
  3864. {
  3865. if (!sp.IsChildAgent)
  3866. {
  3867. m_log.WarnFormat("[SCENE]: Ignoring a child update on a root agent {0} {1} in {2}",
  3868. sp.Name, sp.UUID, Name);
  3869. return false;
  3870. }
  3871. if (cAgentData.SessionID != sp.ControllingClient.SessionId)
  3872. {
  3873. m_log.WarnFormat(
  3874. "[SCENE]: Attempt to update agent {0} with invalid session id {1} (possibly from simulator in older version; tell them to update).",
  3875. sp.UUID, cAgentData.SessionID);
  3876. Console.WriteLine(String.Format("[SCENE]: Attempt to update agent {0} ({1}) with invalid session id {2}",
  3877. sp.UUID, sp.ControllingClient.SessionId, cAgentData.SessionID));
  3878. }
  3879. sp.UpdateChildAgent(cAgentData);
  3880. int ntimes = 20;
  3881. if (cAgentData.SenderWantsToWaitForRoot)
  3882. {
  3883. while (sp.IsChildAgent && ntimes-- > 0)
  3884. Thread.Sleep(1000);
  3885. if (sp.IsChildAgent)
  3886. m_log.WarnFormat(
  3887. "[SCENE]: Found presence {0} {1} unexpectedly still child in {2}",
  3888. sp.Name, sp.UUID, Name);
  3889. else
  3890. m_log.InfoFormat(
  3891. "[SCENE]: Found presence {0} {1} as root in {2} after {3} waits",
  3892. sp.Name, sp.UUID, Name, 20 - ntimes);
  3893. if (sp.IsChildAgent)
  3894. return false;
  3895. }
  3896. return true;
  3897. }
  3898. return false;
  3899. }
  3900. /// <summary>
  3901. /// We've got an update about an agent that sees into this region,
  3902. /// send it to ScenePresence for processing It's only positional data
  3903. /// </summary>
  3904. /// <param name="cAgentData">AgentPosition that contains agent positional data so we can know what to send</param>
  3905. /// <returns>true if we handled it.</returns>
  3906. public virtual bool IncomingUpdateChildAgent(AgentPosition cAgentData)
  3907. {
  3908. // m_log.DebugFormat(
  3909. // "[SCENE PRESENCE]: IncomingChildAgentDataUpdate POSITION for {0} in {1}, position {2}",
  3910. // cAgentData.AgentID, Name, cAgentData.Position);
  3911. ScenePresence childAgentUpdate = GetScenePresence(cAgentData.AgentID);
  3912. if (childAgentUpdate != null)
  3913. {
  3914. // if (childAgentUpdate.ControllingClient.SessionId != cAgentData.SessionID)
  3915. // // Only warn for now
  3916. // m_log.WarnFormat("[SCENE]: Attempt at updating position of agent {0} with invalid session id {1}. Neighbor running older version?",
  3917. // childAgentUpdate.UUID, cAgentData.SessionID);
  3918. // I can't imagine *yet* why we would get an update if the agent is a root agent..
  3919. // however to avoid a race condition crossing borders..
  3920. if (childAgentUpdate.IsChildAgent)
  3921. {
  3922. uint rRegionX = (uint)(cAgentData.RegionHandle >> 40);
  3923. uint rRegionY = (((uint)(cAgentData.RegionHandle)) >> 8);
  3924. uint tRegionX = RegionInfo.RegionLocX;
  3925. uint tRegionY = RegionInfo.RegionLocY;
  3926. //Send Data to ScenePresence
  3927. childAgentUpdate.UpdateChildAgent(cAgentData, tRegionX, tRegionY, rRegionX, rRegionY);
  3928. // Not Implemented:
  3929. //TODO: Do we need to pass the message on to one of our neighbors?
  3930. }
  3931. return true;
  3932. }
  3933. return false;
  3934. }
  3935. /// <summary>
  3936. /// Poll until the requested ScenePresence appears or we timeout.
  3937. /// </summary>
  3938. /// <returns>The scene presence is found, else null.</returns>
  3939. /// <param name='agentID'></param>
  3940. protected virtual ScenePresence WaitGetScenePresence(UUID agentID)
  3941. {
  3942. int ntimes = 120; // 30s
  3943. ScenePresence sp = null;
  3944. while ((sp = GetScenePresence(agentID)) == null && (ntimes-- > 0))
  3945. Thread.Sleep(250);
  3946. if (sp == null)
  3947. m_log.WarnFormat(
  3948. "[SCENE PRESENCE]: Did not find presence with id {0} in {1} before timeout",
  3949. agentID, RegionInfo.RegionName);
  3950. return sp;
  3951. }
  3952. /// <summary>
  3953. /// Authenticated close (via network)
  3954. /// </summary>
  3955. /// <param name="agentID"></param>
  3956. /// <param name="force"></param>
  3957. /// <param name="auth_token"></param>
  3958. /// <returns></returns>
  3959. public bool CloseAgent(UUID agentID, bool force, string auth_token)
  3960. {
  3961. //m_log.DebugFormat("[SCENE]: Processing incoming close agent {0} in region {1} with auth_token {2}", agentID, RegionInfo.RegionName, auth_token);
  3962. // Check that the auth_token is valid
  3963. AgentCircuitData acd = AuthenticateHandler.GetAgentCircuitData(agentID);
  3964. if (acd == null)
  3965. {
  3966. m_log.DebugFormat(
  3967. "[SCENE]: Request to close agent {0} but no such agent in scene {1}. May have been closed previously.",
  3968. agentID, Name);
  3969. return false;
  3970. }
  3971. if (acd.SessionID.ToString() == auth_token)
  3972. {
  3973. return CloseAgent(agentID, force);
  3974. }
  3975. else
  3976. {
  3977. m_log.WarnFormat(
  3978. "[SCENE]: Request to close agent {0} with invalid authorization token {1} in {2}",
  3979. agentID, auth_token, Name);
  3980. }
  3981. return false;
  3982. }
  3983. // public bool IncomingCloseAgent(UUID agentID)
  3984. // {
  3985. // return IncomingCloseAgent(agentID, false);
  3986. // }
  3987. // public bool IncomingCloseChildAgent(UUID agentID)
  3988. // {
  3989. // return IncomingCloseAgent(agentID, true);
  3990. // }
  3991. /// <summary>
  3992. /// Tell a single client to prepare to close.
  3993. /// </summary>
  3994. /// <remarks>
  3995. /// This should only be called if we may close the client but there will be some delay in so doing. Meant for
  3996. /// internal use - other callers should almost certainly called CloseClient().
  3997. /// </remarks>
  3998. /// <param name="sp"></param>
  3999. /// <returns>true if pre-close state notification was successful. false if the agent
  4000. /// was not in a state where it could transition to pre-close.</returns>
  4001. public bool IncomingPreCloseClient(ScenePresence sp)
  4002. {
  4003. lock (m_removeClientLock)
  4004. {
  4005. // We need to avoid a race condition where in, for example, an A B C D region layout, an avatar may
  4006. // teleport from A -> D, but then -> C before A has asked B to close its old child agent. We do not
  4007. // want to obey this close since C may have renewed the child agent lease on B.
  4008. if (sp.DoNotCloseAfterTeleport)
  4009. {
  4010. m_log.DebugFormat(
  4011. "[SCENE]: Not pre-closing {0} agent {1} in {2} since another simulator has re-established the child connection",
  4012. sp.IsChildAgent ? "child" : "root", sp.Name, Name);
  4013. // Need to reset the flag so that a subsequent close after another teleport can succeed.
  4014. sp.DoNotCloseAfterTeleport = false;
  4015. return false;
  4016. }
  4017. if (sp.LifecycleState != ScenePresenceState.Running)
  4018. {
  4019. m_log.DebugFormat(
  4020. "[SCENE]: Called IncomingPreCloseAgent() for {0} in {1} but presence is already in state {2}",
  4021. sp.Name, Name, sp.LifecycleState);
  4022. return false;
  4023. }
  4024. sp.LifecycleState = ScenePresenceState.PreRemove;
  4025. return true;
  4026. }
  4027. }
  4028. /// <summary>
  4029. /// Tell a single agent to disconnect from the region.
  4030. /// </summary>
  4031. /// <param name="agentID"></param>
  4032. /// <param name="force">
  4033. /// Force the agent to close even if it might be in the middle of some other operation. You do not want to
  4034. /// force unless you are absolutely sure that the agent is dead and a normal close is not working.
  4035. /// </param>
  4036. public override bool CloseAgent(UUID agentID, bool force)
  4037. {
  4038. ScenePresence sp;
  4039. lock (m_removeClientLock)
  4040. {
  4041. sp = GetScenePresence(agentID);
  4042. if (sp == null)
  4043. {
  4044. // If there is no scene presence, we may be handling a dead
  4045. // client. These can keep an avatar from reentering a region
  4046. // and since they don't get cleaned up they will stick
  4047. // around until region restart. So, if there is no SP,
  4048. // remove the client as well.
  4049. IClientAPI client = null;
  4050. if (m_clientManager.TryGetValue(agentID, out client))
  4051. {
  4052. m_clientManager.Remove(agentID);
  4053. if (CapsModule != null)
  4054. CapsModule.RemoveCaps(agentID, 0);
  4055. m_log.DebugFormat( "[SCENE]: Dead client for agent ID {0} was cleaned up in {1}", agentID, Name);
  4056. return true;
  4057. }
  4058. m_log.DebugFormat(
  4059. "[SCENE]: Called CloseClient() with agent ID {0} but no such presence is in {1}",
  4060. agentID, Name);
  4061. return false;
  4062. }
  4063. if (sp.LifecycleState != ScenePresenceState.Running && sp.LifecycleState != ScenePresenceState.PreRemove)
  4064. {
  4065. m_log.DebugFormat(
  4066. "[SCENE]: Called CloseClient() for {0} in {1} but presence is already in state {2}",
  4067. sp.Name, Name, sp.LifecycleState);
  4068. return false;
  4069. }
  4070. // We need to avoid a race condition where in, for example, an A B C D region layout, an avatar may
  4071. // teleport from A -> D, but then -> C before A has asked B to close its old child agent. We do not
  4072. // want to obey this close since C may have renewed the child agent lease on B.
  4073. if (sp.DoNotCloseAfterTeleport)
  4074. {
  4075. m_log.DebugFormat(
  4076. "[SCENE]: Not closing {0} agent {1} in {2} since another simulator has re-established the child connection",
  4077. sp.IsChildAgent ? "child" : "root", sp.Name, Name);
  4078. // Need to reset the flag so that a subsequent close after another teleport can succeed.
  4079. sp.DoNotCloseAfterTeleport = false;
  4080. return false;
  4081. }
  4082. sp.LifecycleState = ScenePresenceState.Removing;
  4083. }
  4084. if (sp != null)
  4085. {
  4086. sp.ControllingClient.Close(force, force);
  4087. return true;
  4088. }
  4089. return true;
  4090. }
  4091. /// <summary>
  4092. /// Tries to teleport agent to another region.
  4093. /// </summary>
  4094. /// <remarks>
  4095. /// The region name must exactly match that given.
  4096. /// </remarks>
  4097. /// <param name="remoteClient"></param>
  4098. /// <param name="regionName"></param>
  4099. /// <param name="position"></param>
  4100. /// <param name="lookAt"></param>
  4101. /// <param name="teleportFlags"></param>
  4102. public void RequestTeleportLocation(IClientAPI remoteClient, string regionName, Vector3 position,
  4103. Vector3 lookat, uint teleportFlags)
  4104. {
  4105. if (EntityTransferModule == null)
  4106. {
  4107. m_log.DebugFormat("[SCENE]: Unable to perform teleports: no AgentTransferModule is active");
  4108. return;
  4109. }
  4110. ScenePresence sp = GetScenePresence(remoteClient.AgentId);
  4111. if (sp == null || sp.IsDeleted || sp.IsInTransit)
  4112. return;
  4113. ulong regionHandle = 0;
  4114. if(regionName == RegionInfo.RegionName)
  4115. regionHandle = RegionInfo.RegionHandle;
  4116. else
  4117. {
  4118. GridRegion region = GridService.GetRegionByName(RegionInfo.ScopeID, regionName);
  4119. if (region != null)
  4120. regionHandle = region.RegionHandle;
  4121. }
  4122. if(regionHandle == 0)
  4123. {
  4124. // can't find the region: Tell viewer and abort
  4125. remoteClient.SendTeleportFailed("The region '" + regionName + "' could not be found.");
  4126. return;
  4127. }
  4128. EntityTransferModule.Teleport(sp, regionHandle, position, lookat, teleportFlags);
  4129. }
  4130. /// <summary>
  4131. /// Tries to teleport agent to other region.
  4132. /// </summary>
  4133. /// <param name="remoteClient"></param>
  4134. /// <param name="regionHandle"></param>
  4135. /// <param name="position"></param>
  4136. /// <param name="lookAt"></param>
  4137. /// <param name="teleportFlags"></param>
  4138. public void RequestTeleportLocation(IClientAPI remoteClient, ulong regionHandle, Vector3 position,
  4139. Vector3 lookAt, uint teleportFlags)
  4140. {
  4141. if (EntityTransferModule == null)
  4142. {
  4143. m_log.DebugFormat("[SCENE]: Unable to perform teleports: no AgentTransferModule is active");
  4144. return;
  4145. }
  4146. ScenePresence sp = GetScenePresence(remoteClient.AgentId);
  4147. if (sp == null || sp.IsDeleted || sp.IsInTransit)
  4148. return;
  4149. EntityTransferModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
  4150. }
  4151. public bool CrossAgentToNewRegion(ScenePresence agent, bool isFlying)
  4152. {
  4153. if (EntityTransferModule != null)
  4154. {
  4155. return EntityTransferModule.Cross(agent, isFlying);
  4156. }
  4157. else
  4158. {
  4159. m_log.DebugFormat("[SCENE]: Unable to cross agent to neighbouring region, because there is no AgentTransferModule");
  4160. }
  4161. return false;
  4162. }
  4163. public void SendOutChildAgentUpdates(AgentPosition cadu, ScenePresence presence)
  4164. {
  4165. m_sceneGridService.SendChildAgentDataUpdate(cadu, presence);
  4166. }
  4167. #endregion
  4168. #region Other Methods
  4169. protected override IConfigSource GetConfig()
  4170. {
  4171. return m_config;
  4172. }
  4173. #endregion
  4174. public void HandleObjectPermissionsUpdate(IClientAPI controller, UUID agentID, UUID sessionID, byte field, uint localId, uint mask, byte set)
  4175. {
  4176. // Check for spoofing.. since this is permissions we're talking about here!
  4177. if ((controller.SessionId == sessionID) && (controller.AgentId == agentID))
  4178. {
  4179. // Tell the object to do permission update
  4180. if (localId != 0)
  4181. {
  4182. SceneObjectGroup chObjectGroup = GetGroupByPrim(localId);
  4183. if (chObjectGroup != null)
  4184. {
  4185. chObjectGroup.UpdatePermissions(agentID, field, localId, mask, set);
  4186. }
  4187. }
  4188. }
  4189. }
  4190. /// <summary>
  4191. /// Causes all clients to get a full object update on all of the objects in the scene.
  4192. /// </summary>
  4193. public void ForceClientUpdate()
  4194. {
  4195. EntityBase[] entityList = GetEntities();
  4196. foreach (EntityBase ent in entityList)
  4197. {
  4198. if (ent is SceneObjectGroup)
  4199. {
  4200. ((SceneObjectGroup)ent).ScheduleGroupForFullUpdate();
  4201. }
  4202. }
  4203. }
  4204. /// <summary>
  4205. /// This is currently only used for scale (to scale to MegaPrim size)
  4206. /// There is a console command that calls this in OpenSimMain
  4207. /// </summary>
  4208. /// <param name="cmdparams"></param>
  4209. public void HandleEditCommand(string[] cmdparams)
  4210. {
  4211. m_log.DebugFormat("Searching for Primitive: '{0}'", cmdparams[2]);
  4212. EntityBase[] entityList = GetEntities();
  4213. foreach (EntityBase ent in entityList)
  4214. {
  4215. if (ent is SceneObjectGroup)
  4216. {
  4217. SceneObjectPart part = ((SceneObjectGroup)ent).GetPart(((SceneObjectGroup)ent).UUID);
  4218. if (part != null)
  4219. {
  4220. if (part.Name == cmdparams[2])
  4221. {
  4222. part.Resize(
  4223. new Vector3(Convert.ToSingle(cmdparams[3]), Convert.ToSingle(cmdparams[4]),
  4224. Convert.ToSingle(cmdparams[5])));
  4225. m_log.DebugFormat("Edited scale of Primitive: {0}", part.Name);
  4226. }
  4227. }
  4228. }
  4229. }
  4230. }
  4231. #region Script Handling Methods
  4232. /// <summary>
  4233. /// Console command handler to send script command to script engine.
  4234. /// </summary>
  4235. /// <param name="args"></param>
  4236. public void SendCommandToPlugins(string[] args)
  4237. {
  4238. m_eventManager.TriggerOnPluginConsole(args);
  4239. }
  4240. public LandData GetLandData(float x, float y)
  4241. {
  4242. ILandObject parcel = LandChannel.GetLandObject(x, y);
  4243. if (parcel == null)
  4244. return null;
  4245. return parcel.LandData;
  4246. }
  4247. /// <summary>
  4248. /// Get LandData by position.
  4249. /// </summary>
  4250. /// <param name="pos"></param>
  4251. /// <returns></returns>
  4252. public LandData GetLandData(Vector3 pos)
  4253. {
  4254. return GetLandData(pos.X, pos.Y);
  4255. }
  4256. public LandData GetLandData(uint x, uint y)
  4257. {
  4258. // m_log.DebugFormat("[SCENE]: returning land for {0},{1}", x, y);
  4259. ILandObject parcel = LandChannel.GetLandObject((int)x, (int)y);
  4260. if (parcel == null)
  4261. return null;
  4262. return parcel.LandData;
  4263. }
  4264. #endregion
  4265. #region Script Engine
  4266. public bool LSLScriptDanger(SceneObjectPart part, Vector3 pos)
  4267. {
  4268. ILandObject parcel = LandChannel.GetLandObject(pos.X, pos.Y);
  4269. if (parcel == null)
  4270. return true;
  4271. LandData ldata = parcel.LandData;
  4272. if (ldata == null)
  4273. return true;
  4274. uint landflags = ldata.Flags;
  4275. uint mask = (uint)(ParcelFlags.CreateObjects | ParcelFlags.AllowAPrimitiveEntry);
  4276. if((landflags & mask) != mask)
  4277. return true;
  4278. if((landflags & (uint)ParcelFlags.AllowOtherScripts) != 0)
  4279. return false;
  4280. if(part == null)
  4281. return true;
  4282. if(part.GroupID == ldata.GroupID && (landflags & (uint)ParcelFlags.AllowGroupScripts) != 0)
  4283. return false;
  4284. return true;
  4285. }
  4286. private bool ScriptDanger(SceneObjectPart part, Vector3 pos)
  4287. {
  4288. if (part == null)
  4289. return false;
  4290. ILandObject parcel = LandChannel.GetLandObject(pos.X, pos.Y);
  4291. if (parcel != null)
  4292. {
  4293. if ((parcel.LandData.Flags & (uint)ParcelFlags.AllowOtherScripts) != 0)
  4294. return true;
  4295. if ((part.OwnerID == parcel.LandData.OwnerID) || Permissions.IsGod(part.OwnerID))
  4296. return true;
  4297. if (((parcel.LandData.Flags & (uint)ParcelFlags.AllowGroupScripts) != 0)
  4298. && (parcel.LandData.GroupID != UUID.Zero) && (parcel.LandData.GroupID == part.GroupID))
  4299. return true;
  4300. }
  4301. else
  4302. {
  4303. if (pos.X > 0f && pos.X < RegionInfo.RegionSizeX && pos.Y > 0f && pos.Y < RegionInfo.RegionSizeY)
  4304. return true;
  4305. }
  4306. return false;
  4307. }
  4308. public bool PipeEventsForScript(uint localID)
  4309. {
  4310. SceneObjectPart part = GetSceneObjectPart(localID);
  4311. if (part != null)
  4312. {
  4313. SceneObjectPart parent = part.ParentGroup.RootPart;
  4314. return ScriptDanger(parent, parent.GetWorldPosition());
  4315. }
  4316. else
  4317. {
  4318. return false;
  4319. }
  4320. }
  4321. #endregion
  4322. #region SceneGraph wrapper methods
  4323. /// <summary>
  4324. ///
  4325. /// </summary>
  4326. /// <param name="localID"></param>
  4327. /// <returns></returns>
  4328. public UUID ConvertLocalIDToFullID(uint localID)
  4329. {
  4330. return m_sceneGraph.ConvertLocalIDToFullID(localID);
  4331. }
  4332. public void SwapRootAgentCount(bool rootChildChildRootTF)
  4333. {
  4334. m_sceneGraph.SwapRootChildAgent(rootChildChildRootTF);
  4335. }
  4336. public void AddPhysicalPrim(int num)
  4337. {
  4338. m_sceneGraph.AddPhysicalPrim(num);
  4339. }
  4340. public void RemovePhysicalPrim(int num)
  4341. {
  4342. m_sceneGraph.RemovePhysicalPrim(num);
  4343. }
  4344. public int GetRootAgentCount()
  4345. {
  4346. return m_sceneGraph.GetRootAgentCount();
  4347. }
  4348. public int GetChildAgentCount()
  4349. {
  4350. return m_sceneGraph.GetChildAgentCount();
  4351. }
  4352. /// <summary>
  4353. /// Request a scene presence by UUID. Fast, indexed lookup.
  4354. /// </summary>
  4355. /// <param name="agentID"></param>
  4356. /// <returns>null if the presence was not found</returns>
  4357. public ScenePresence GetScenePresence(UUID agentID)
  4358. {
  4359. return m_sceneGraph.GetScenePresence(agentID);
  4360. }
  4361. /// <summary>
  4362. /// Request the scene presence by name.
  4363. /// </summary>
  4364. /// <param name="firstName"></param>
  4365. /// <param name="lastName"></param>
  4366. /// <returns>null if the presence was not found</returns>
  4367. public ScenePresence GetScenePresence(string firstName, string lastName)
  4368. {
  4369. return m_sceneGraph.GetScenePresence(firstName, lastName);
  4370. }
  4371. /// <summary>
  4372. /// Request the scene presence by localID.
  4373. /// </summary>
  4374. /// <param name="localID"></param>
  4375. /// <returns>null if the presence was not found</returns>
  4376. public ScenePresence GetScenePresence(uint localID)
  4377. {
  4378. return m_sceneGraph.GetScenePresence(localID);
  4379. }
  4380. /// <summary>
  4381. /// Gets all the scene presences in this scene.
  4382. /// </summary>
  4383. /// <remarks>
  4384. /// This method will return both root and child scene presences.
  4385. ///
  4386. /// Consider using ForEachScenePresence() or ForEachRootScenePresence() if possible since these will not
  4387. /// involving creating a new List object.
  4388. /// </remarks>
  4389. /// <returns>
  4390. /// A list of the scene presences. Adding or removing from the list will not affect the presences in the scene.
  4391. /// </returns>
  4392. public List<ScenePresence> GetScenePresences()
  4393. {
  4394. return new List<ScenePresence>(m_sceneGraph.GetScenePresences());
  4395. }
  4396. /// <summary>
  4397. /// Performs action on all avatars in the scene (root scene presences)
  4398. /// Avatars may be an NPC or a 'real' client.
  4399. /// </summary>
  4400. /// <param name="action"></param>
  4401. public void ForEachRootScenePresence(Action<ScenePresence> action)
  4402. {
  4403. m_sceneGraph.ForEachAvatar(action);
  4404. }
  4405. /// <summary>
  4406. /// Performs action on all scene presences (root and child)
  4407. /// </summary>
  4408. /// <param name="action"></param>
  4409. public void ForEachScenePresence(Action<ScenePresence> action)
  4410. {
  4411. m_sceneGraph.ForEachScenePresence(action);
  4412. }
  4413. /// <summary>
  4414. /// Get all the scene object groups.
  4415. /// </summary>
  4416. /// <returns>
  4417. /// The scene object groups. If the scene is empty then an empty list is returned.
  4418. /// </returns>
  4419. public List<SceneObjectGroup> GetSceneObjectGroups()
  4420. {
  4421. return m_sceneGraph.GetSceneObjectGroups();
  4422. }
  4423. /// <summary>
  4424. /// Get a group via its UUID
  4425. /// </summary>
  4426. /// <param name="fullID"></param>
  4427. /// <returns>null if no group with that id exists</returns>
  4428. public SceneObjectGroup GetSceneObjectGroup(UUID fullID)
  4429. {
  4430. return m_sceneGraph.GetSceneObjectGroup(fullID);
  4431. }
  4432. /// <summary>
  4433. /// Get a group via its local ID
  4434. /// </summary>
  4435. /// <remarks>This will only return a group if the local ID matches a root part</remarks>
  4436. /// <param name="localID"></param>
  4437. /// <returns>null if no group with that id exists</returns>
  4438. public SceneObjectGroup GetSceneObjectGroup(uint localID)
  4439. {
  4440. return m_sceneGraph.GetSceneObjectGroup(localID);
  4441. }
  4442. /// <summary>
  4443. /// Get a group 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>null if no group with that name exists</returns>
  4448. public SceneObjectGroup GetSceneObjectGroup(string name)
  4449. {
  4450. return m_sceneGraph.GetSceneObjectGroup(name);
  4451. }
  4452. /// <summary>
  4453. /// Attempt to get the SOG via its UUID
  4454. /// </summary>
  4455. /// <param name="fullID"></param>
  4456. /// <param name="sog"></param>
  4457. /// <returns></returns>
  4458. public bool TryGetSceneObjectGroup(UUID fullID, out SceneObjectGroup sog)
  4459. {
  4460. sog = GetSceneObjectGroup(fullID);
  4461. return sog != null;
  4462. }
  4463. /// <summary>
  4464. /// Get a prim by name from the scene (will return the first
  4465. /// found, if there are more than one prim with the same name)
  4466. /// </summary>
  4467. /// <param name="name"></param>
  4468. /// <returns></returns>
  4469. public SceneObjectPart GetSceneObjectPart(string name)
  4470. {
  4471. return m_sceneGraph.GetSceneObjectPart(name);
  4472. }
  4473. /// <summary>
  4474. /// Get a prim via its local id
  4475. /// </summary>
  4476. /// <param name="localID"></param>
  4477. /// <returns></returns>
  4478. public SceneObjectPart GetSceneObjectPart(uint localID)
  4479. {
  4480. return m_sceneGraph.GetSceneObjectPart(localID);
  4481. }
  4482. /// <summary>
  4483. /// Get a prim via its UUID
  4484. /// </summary>
  4485. /// <param name="fullID"></param>
  4486. /// <returns></returns>
  4487. public SceneObjectPart GetSceneObjectPart(UUID fullID)
  4488. {
  4489. return m_sceneGraph.GetSceneObjectPart(fullID);
  4490. }
  4491. /// <summary>
  4492. /// Attempt to get a prim via its UUID
  4493. /// </summary>
  4494. /// <param name="fullID"></param>
  4495. /// <param name="sop"></param>
  4496. /// <returns></returns>
  4497. public bool TryGetSceneObjectPart(UUID fullID, out SceneObjectPart sop)
  4498. {
  4499. sop = GetSceneObjectPart(fullID);
  4500. return sop != null;
  4501. }
  4502. /// <summary>
  4503. /// Get a scene object group that contains the prim with the given local id
  4504. /// </summary>
  4505. /// <param name="localID"></param>
  4506. /// <returns>null if no scene object group containing that prim is found</returns>
  4507. public SceneObjectGroup GetGroupByPrim(uint localID)
  4508. {
  4509. return m_sceneGraph.GetGroupByPrim(localID);
  4510. }
  4511. /// <summary>
  4512. /// Get a scene object group that contains the prim with the given uuid
  4513. /// </summary>
  4514. /// <param name="fullID"></param>
  4515. /// <returns>null if no scene object group containing that prim is found</returns>
  4516. public SceneObjectGroup GetGroupByPrim(UUID fullID)
  4517. {
  4518. return m_sceneGraph.GetGroupByPrim(fullID);
  4519. }
  4520. public override bool TryGetScenePresence(UUID agentID, out ScenePresence sp)
  4521. {
  4522. return m_sceneGraph.TryGetScenePresence(agentID, out sp);
  4523. }
  4524. public bool TryGetAvatarByName(string avatarName, out ScenePresence avatar)
  4525. {
  4526. return m_sceneGraph.TryGetAvatarByName(avatarName, out avatar);
  4527. }
  4528. /// <summary>
  4529. /// Perform an action on all clients with an avatar in this scene (root only)
  4530. /// </summary>
  4531. /// <param name="action"></param>
  4532. public void ForEachRootClient(Action<IClientAPI> action)
  4533. {
  4534. ForEachRootScenePresence(delegate(ScenePresence presence)
  4535. {
  4536. action(presence.ControllingClient);
  4537. });
  4538. }
  4539. /// <summary>
  4540. /// Perform an action on all clients connected to the region (root and child)
  4541. /// </summary>
  4542. /// <param name="action"></param>
  4543. public void ForEachClient(Action<IClientAPI> action)
  4544. {
  4545. m_clientManager.ForEach(action);
  4546. }
  4547. public int GetNumberOfClients()
  4548. {
  4549. return m_clientManager.Count;
  4550. }
  4551. public bool TryGetClient(UUID avatarID, out IClientAPI client)
  4552. {
  4553. return m_clientManager.TryGetValue(avatarID, out client);
  4554. }
  4555. public bool TryGetClient(System.Net.IPEndPoint remoteEndPoint, out IClientAPI client)
  4556. {
  4557. return m_clientManager.TryGetValue(remoteEndPoint, out client);
  4558. }
  4559. public void ForEachSOG(Action<SceneObjectGroup> action)
  4560. {
  4561. m_sceneGraph.ForEachSOG(action);
  4562. }
  4563. /// <summary>
  4564. /// Returns a list of the entities in the scene. This is a new list so operations perform on the list itself
  4565. /// will not affect the original list of objects in the scene.
  4566. /// </summary>
  4567. /// <returns></returns>
  4568. public EntityBase[] GetEntities()
  4569. {
  4570. return m_sceneGraph.GetEntities();
  4571. }
  4572. #endregion
  4573. // Commented pending deletion since this method no longer appears to do anything at all
  4574. // public bool NeedSceneCacheClear(UUID agentID)
  4575. // {
  4576. // IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
  4577. // if (inv == null)
  4578. // return true;
  4579. //
  4580. // return inv.NeedSceneCacheClear(agentID, this);
  4581. // }
  4582. public void CleanTempObjects()
  4583. {
  4584. DateTime now = DateTime.UtcNow;
  4585. EntityBase[] entities = GetEntities();
  4586. foreach (EntityBase obj in entities)
  4587. {
  4588. if (obj is SceneObjectGroup)
  4589. {
  4590. SceneObjectGroup grp = (SceneObjectGroup)obj;
  4591. if (!grp.IsDeleted)
  4592. {
  4593. if ((grp.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
  4594. {
  4595. if (grp.GetSittingAvatarsCount() == 0 && grp.RootPart.Expires <= now)
  4596. DeleteSceneObject(grp, false);
  4597. }
  4598. }
  4599. }
  4600. }
  4601. }
  4602. public void DeleteFromStorage(UUID uuid)
  4603. {
  4604. SimulationDataService.RemoveObject(uuid, RegionInfo.RegionID);
  4605. }
  4606. public int GetHealth(out int flags, out string message)
  4607. {
  4608. // Returns:
  4609. // 1 = sim is up and accepting http requests. The heartbeat has
  4610. // stopped and the sim is probably locked up, but a remote
  4611. // admin restart may succeed
  4612. //
  4613. // 2 = Sim is up and the heartbeat is running. The sim is likely
  4614. // usable for people within
  4615. //
  4616. // 3 = Sim is up and one packet thread is running. Sim is
  4617. // unstable and will not accept new logins
  4618. //
  4619. // 4 = Sim is up and both packet threads are running. Sim is
  4620. // likely usable
  4621. //
  4622. // 5 = We have seen a new user enter within the past 4 minutes
  4623. // which can be seen as positive confirmation of sim health
  4624. //
  4625. int health = 1; // Start at 1, means we're up
  4626. flags = 0;
  4627. message = String.Empty;
  4628. CheckHeartbeat();
  4629. if (m_firstHeartbeat || (m_lastIncoming == 0 && m_lastOutgoing == 0))
  4630. {
  4631. // We're still starting
  4632. // 0 means "in startup", it can't happen another way, since
  4633. // to get here, we must be able to accept http connections
  4634. return 0;
  4635. }
  4636. if ((Util.EnvironmentTickCountSubtract(m_lastFrameTick)) < 2000)
  4637. {
  4638. health+=1;
  4639. flags |= 1;
  4640. }
  4641. if (Util.EnvironmentTickCountSubtract(m_lastIncoming) < 2000)
  4642. {
  4643. health+=1;
  4644. flags |= 2;
  4645. }
  4646. if (Util.EnvironmentTickCountSubtract(m_lastOutgoing) < 2000)
  4647. {
  4648. health+=1;
  4649. flags |= 4;
  4650. }
  4651. /*
  4652. else
  4653. {
  4654. int pid = System.Diagnostics.Process.GetCurrentProcess().Id;
  4655. System.Diagnostics.Process proc = new System.Diagnostics.Process();
  4656. proc.EnableRaisingEvents=false;
  4657. proc.StartInfo.FileName = "/bin/kill";
  4658. proc.StartInfo.Arguments = "-QUIT " + pid.ToString();
  4659. proc.Start();
  4660. proc.WaitForExit();
  4661. Thread.Sleep(1000);
  4662. Environment.Exit(1);
  4663. }
  4664. */
  4665. if (flags != 7)
  4666. return health;
  4667. // A login in the last 4 mins? We can't be doing too badly
  4668. //
  4669. if (Util.EnvironmentTickCountSubtract(m_LastLogin) < 240000)
  4670. health++;
  4671. else
  4672. return health;
  4673. return health;
  4674. }
  4675. // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
  4676. // update non-physical objects like the joint proxy objects that represent the position
  4677. // of the joints in the scene.
  4678. // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
  4679. // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
  4680. // from within the OdePhysicsScene.
  4681. protected internal void jointMoved(PhysicsJoint joint)
  4682. {
  4683. // m_parentScene.PhysicsScene.DumpJointInfo(); // non-thread-locked version; we should already be in a lock (OdeLock) when this callback is invoked
  4684. SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
  4685. if (jointProxyObject == null)
  4686. {
  4687. jointErrorMessage(joint, "WARNING, joint proxy not found, name " + joint.ObjectNameInScene);
  4688. return;
  4689. }
  4690. // now update the joint proxy object in the scene to have the position of the joint as returned by the physics engine
  4691. SceneObjectPart trackedBody = GetSceneObjectPart(joint.TrackedBodyName); // FIXME: causes a sequential lookup
  4692. 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.
  4693. jointProxyObject.Velocity = trackedBody.Velocity;
  4694. jointProxyObject.AngularVelocity = trackedBody.AngularVelocity;
  4695. switch (joint.Type)
  4696. {
  4697. case PhysicsJointType.Ball:
  4698. {
  4699. Vector3 jointAnchor = PhysicsScene.GetJointAnchor(joint);
  4700. Vector3 proxyPos = jointAnchor;
  4701. jointProxyObject.ParentGroup.UpdateGroupPosition(proxyPos); // schedules the entire group for a terse update
  4702. }
  4703. break;
  4704. case PhysicsJointType.Hinge:
  4705. {
  4706. Vector3 jointAnchor = PhysicsScene.GetJointAnchor(joint);
  4707. // Normally, we would just ask the physics scene to return the axis for the joint.
  4708. // Unfortunately, ODE sometimes returns <0,0,0> for the joint axis, which should
  4709. // never occur. Therefore we cannot rely on ODE to always return a correct joint axis.
  4710. // Therefore the following call does not always work:
  4711. //PhysicsVector phyJointAxis = _PhyScene.GetJointAxis(joint);
  4712. // instead we compute the joint orientation by saving the original joint orientation
  4713. // relative to one of the jointed bodies, and applying this transformation
  4714. // to the current position of the jointed bodies (the tracked body) to compute the
  4715. // current joint orientation.
  4716. if (joint.TrackedBodyName == null)
  4717. {
  4718. jointErrorMessage(joint, "joint.TrackedBodyName is null, joint " + joint.ObjectNameInScene);
  4719. }
  4720. Vector3 proxyPos = jointAnchor;
  4721. Quaternion q = trackedBody.RotationOffset * joint.LocalRotation;
  4722. jointProxyObject.ParentGroup.UpdateGroupPosition(proxyPos); // schedules the entire group for a terse update
  4723. jointProxyObject.ParentGroup.UpdateGroupRotationR(q); // schedules the entire group for a terse update
  4724. }
  4725. break;
  4726. }
  4727. }
  4728. // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
  4729. // update non-physical objects like the joint proxy objects that represent the position
  4730. // of the joints in the scene.
  4731. // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
  4732. // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
  4733. // from within the OdePhysicsScene.
  4734. protected internal void jointDeactivated(PhysicsJoint joint)
  4735. {
  4736. //m_log.Debug("[NINJA] SceneGraph.jointDeactivated, joint:" + joint.ObjectNameInScene);
  4737. SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
  4738. if (jointProxyObject == null)
  4739. {
  4740. jointErrorMessage(joint, "WARNING, trying to deactivate (stop interpolation of) joint proxy, but not found, name " + joint.ObjectNameInScene);
  4741. return;
  4742. }
  4743. // turn the proxy non-physical, which also stops its client-side interpolation
  4744. bool wasUsingPhysics = ((jointProxyObject.Flags & PrimFlags.Physics) != 0);
  4745. if (wasUsingPhysics)
  4746. {
  4747. 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
  4748. }
  4749. }
  4750. // This callback allows the PhysicsScene to call back to its caller (the SceneGraph) and
  4751. // alert the user of errors by using the debug channel in the same way that scripts alert
  4752. // the user of compile errors.
  4753. // This routine is normally called from within a lock (OdeLock) from within the OdePhysicsScene
  4754. // WARNING: be careful of deadlocks here if you manipulate the scene. Remember you are being called
  4755. // from within the OdePhysicsScene.
  4756. public void jointErrorMessage(PhysicsJoint joint, string message)
  4757. {
  4758. if (joint != null)
  4759. {
  4760. if (joint.ErrorMessageCount > PhysicsJoint.maxErrorMessages)
  4761. return;
  4762. SceneObjectPart jointProxyObject = GetSceneObjectPart(joint.ObjectNameInScene);
  4763. if (jointProxyObject != null)
  4764. {
  4765. SimChat(Utils.StringToBytes("[NINJA]: " + message),
  4766. ChatTypeEnum.DebugChannel,
  4767. 2147483647,
  4768. jointProxyObject.AbsolutePosition,
  4769. jointProxyObject.Name,
  4770. jointProxyObject.UUID,
  4771. false);
  4772. joint.ErrorMessageCount++;
  4773. if (joint.ErrorMessageCount > PhysicsJoint.maxErrorMessages)
  4774. {
  4775. SimChat(Utils.StringToBytes("[NINJA]: Too many messages for this joint, suppressing further messages."),
  4776. ChatTypeEnum.DebugChannel,
  4777. 2147483647,
  4778. jointProxyObject.AbsolutePosition,
  4779. jointProxyObject.Name,
  4780. jointProxyObject.UUID,
  4781. false);
  4782. }
  4783. }
  4784. else
  4785. {
  4786. // couldn't find the joint proxy object; the error message is silently suppressed
  4787. }
  4788. }
  4789. }
  4790. public Scene ConsoleScene()
  4791. {
  4792. if (MainConsole.Instance == null)
  4793. return null;
  4794. if (MainConsole.Instance.ConsoleScene is Scene)
  4795. return (Scene)MainConsole.Instance.ConsoleScene;
  4796. return null;
  4797. }
  4798. // Get terrain height at the specified <x,y> location.
  4799. // Presumes the underlying implementation is a heightmap which is a 1m grid.
  4800. // Finds heightmap grid points before and after the point and
  4801. // does a linear approximation of the height at this intermediate point.
  4802. public float GetGroundHeight(float x, float y)
  4803. {
  4804. if (x < 0)
  4805. x = 0;
  4806. if (x >= Heightmap.Width)
  4807. x = Heightmap.Width - 1;
  4808. if (y < 0)
  4809. y = 0;
  4810. if (y >= Heightmap.Height)
  4811. y = Heightmap.Height - 1;
  4812. Vector3 p0 = new Vector3(x, y, (float)Heightmap[(int)x, (int)y]);
  4813. Vector3 p1 = p0;
  4814. Vector3 p2 = p0;
  4815. p1.X += 1.0f;
  4816. if (p1.X < Heightmap.Width)
  4817. p1.Z = (float)Heightmap[(int)p1.X, (int)p1.Y];
  4818. p2.Y += 1.0f;
  4819. if (p2.Y < Heightmap.Height)
  4820. p2.Z = (float)Heightmap[(int)p2.X, (int)p2.Y];
  4821. Vector3 v0 = new Vector3(p1.X - p0.X, p1.Y - p0.Y, p1.Z - p0.Z);
  4822. Vector3 v1 = new Vector3(p2.X - p0.X, p2.Y - p0.Y, p2.Z - p0.Z);
  4823. v0.Normalize();
  4824. v1.Normalize();
  4825. Vector3 vsn = new Vector3();
  4826. vsn.X = (v0.Y * v1.Z) - (v0.Z * v1.Y);
  4827. vsn.Y = (v0.Z * v1.X) - (v0.X * v1.Z);
  4828. vsn.Z = (v0.X * v1.Y) - (v0.Y * v1.X);
  4829. vsn.Normalize();
  4830. float xdiff = x - (float)((int)x);
  4831. float ydiff = y - (float)((int)y);
  4832. return (((vsn.X * xdiff) + (vsn.Y * ydiff)) / (-1 * vsn.Z)) + p0.Z;
  4833. }
  4834. private void CheckHeartbeat()
  4835. {
  4836. if (m_firstHeartbeat)
  4837. return;
  4838. if ((Util.EnvironmentTickCountSubtract(m_lastFrameTick)) > 5000)
  4839. Start();
  4840. }
  4841. public override ISceneObject DeserializeObject(string representation)
  4842. {
  4843. return SceneObjectSerializer.FromXml2Format(representation);
  4844. }
  4845. public override bool AllowScriptCrossings
  4846. {
  4847. get { return m_allowScriptCrossings; }
  4848. }
  4849. public Vector3 GetNearestAllowedPosition(ScenePresence avatar)
  4850. {
  4851. return GetNearestAllowedPosition(avatar, null);
  4852. }
  4853. public Vector3 GetNearestAllowedPosition(ScenePresence avatar, ILandObject excludeParcel)
  4854. {
  4855. Vector3 pos = avatar.AbsolutePosition;
  4856. ILandObject nearestParcel = GetNearestAllowedParcel(avatar.UUID, pos.X, pos.Y, excludeParcel);
  4857. if (nearestParcel != null)
  4858. {
  4859. Vector2? nearestPoint = null;
  4860. Vector3 dir = -avatar.Velocity;
  4861. float dirlen = dir.Length();
  4862. if(dirlen > 1.0f)
  4863. //Try to get a location that feels like where they came from
  4864. nearestPoint = nearestParcel.GetNearestPointAlongDirection(pos, dir);
  4865. if (nearestPoint == null)
  4866. nearestPoint = nearestParcel.GetNearestPoint(pos);
  4867. if (nearestPoint != null)
  4868. {
  4869. return GetPositionAtAvatarHeightOrGroundHeight(avatar,
  4870. nearestPoint.Value.X, nearestPoint.Value.Y);
  4871. }
  4872. ILandObject dest = LandChannel.GetLandObject(avatar.lastKnownAllowedPosition.X, avatar.lastKnownAllowedPosition.Y);
  4873. if (dest != excludeParcel)
  4874. {
  4875. // Ultimate backup if we have no idea where they are and
  4876. // the last allowed position was in another parcel
  4877. m_log.Debug("Have no idea where they are, sending them to: " + avatar.lastKnownAllowedPosition.ToString());
  4878. return avatar.lastKnownAllowedPosition;
  4879. }
  4880. // else fall through to region edge
  4881. }
  4882. //Go to the edge, this happens in teleporting to a region with no available parcels
  4883. Vector3 nearestRegionEdgePoint = GetNearestRegionEdgePosition(avatar);
  4884. //Debug.WriteLine("They are really in a place they don't belong, sending them to: " + nearestRegionEdgePoint.ToString());
  4885. return nearestRegionEdgePoint;
  4886. }
  4887. private Vector3 GetParcelCenterAtGround(ILandObject parcel)
  4888. {
  4889. Vector2 center = parcel.CenterPoint;
  4890. return GetPositionAtGround(center.X, center.Y);
  4891. }
  4892. public ILandObject GetNearestAllowedParcel(UUID avatarId, float x, float y)
  4893. {
  4894. return GetNearestAllowedParcel(avatarId, x, y, null);
  4895. }
  4896. public ILandObject GetNearestAllowedParcel(UUID avatarId, float x, float y, ILandObject excludeParcel)
  4897. {
  4898. if(LandChannel == null)
  4899. return null;
  4900. List<ILandObject> all = LandChannel.AllParcels();
  4901. if(all == null || all.Count == 0)
  4902. return null;
  4903. float minParcelDistanceSQ = float.MaxValue;
  4904. ILandObject nearestParcel = null;
  4905. Vector2 curCenter;
  4906. float parcelDistanceSQ;
  4907. foreach (var parcel in all)
  4908. {
  4909. if (parcel != excludeParcel && !parcel.IsEitherBannedOrRestricted(avatarId))
  4910. {
  4911. curCenter = parcel.CenterPoint;
  4912. curCenter.X -= x;
  4913. curCenter.Y -= y;
  4914. parcelDistanceSQ = curCenter.LengthSquared();
  4915. if (parcelDistanceSQ < minParcelDistanceSQ)
  4916. {
  4917. minParcelDistanceSQ = parcelDistanceSQ;
  4918. nearestParcel = parcel;
  4919. }
  4920. }
  4921. }
  4922. return nearestParcel;
  4923. }
  4924. private Vector2 GetParcelSafeCorner(ILandObject parcel)
  4925. {
  4926. Vector2 place = parcel.StartPoint;
  4927. place.X += 2f;
  4928. place.Y += 2f;
  4929. return place;
  4930. }
  4931. private Vector3 GetNearestRegionEdgePosition(ScenePresence avatar)
  4932. {
  4933. float posX = avatar.AbsolutePosition.X;
  4934. float posY = avatar.AbsolutePosition.Y;
  4935. float regionSizeX = RegionInfo.RegionSizeX;
  4936. float halfRegionSizeX = regionSizeX * 0.5f;
  4937. float regionSizeY = RegionInfo.RegionSizeY;
  4938. float halfRegionSizeY = regionSizeY * 0.5f;
  4939. float xdistance = posX < halfRegionSizeX ? posX : regionSizeX - posX;
  4940. float ydistance = posY < halfRegionSizeY ? posY : regionSizeY - posY;
  4941. //find out what vertical edge to go to
  4942. if (xdistance < ydistance)
  4943. {
  4944. if (posX < halfRegionSizeX)
  4945. return GetPositionAtAvatarHeightOrGroundHeight(avatar, 0.5f, posY);
  4946. else
  4947. return GetPositionAtAvatarHeightOrGroundHeight(avatar, regionSizeX - 0.5f, posY);
  4948. }
  4949. //find out what horizontal edge to go to
  4950. else
  4951. {
  4952. if (posY < halfRegionSizeY)
  4953. return GetPositionAtAvatarHeightOrGroundHeight(avatar, posX, 0.5f);
  4954. else
  4955. return GetPositionAtAvatarHeightOrGroundHeight(avatar, posX, regionSizeY - 0.5f);
  4956. }
  4957. }
  4958. private Vector3 GetPositionAtAvatarHeightOrGroundHeight(ScenePresence avatar, float x, float y)
  4959. {
  4960. Vector3 ground = GetPositionAtGround(x, y);
  4961. if(avatar.Appearance != null)
  4962. ground.Z += avatar.Appearance.AvatarHeight * 0.5f;
  4963. else
  4964. ground.Z += 0.8f;
  4965. if (avatar.AbsolutePosition.Z > ground.Z)
  4966. {
  4967. ground.Z = avatar.AbsolutePosition.Z;
  4968. }
  4969. return ground;
  4970. }
  4971. private Vector3 GetPositionAtGround(float x, float y)
  4972. {
  4973. return new Vector3(x, y, GetGroundHeight(x, y));
  4974. }
  4975. public List<UUID> GetEstateRegions(int estateID)
  4976. {
  4977. IEstateDataService estateDataService = EstateDataService;
  4978. if (estateDataService == null)
  4979. return new List<UUID>(0);
  4980. return estateDataService.GetRegions(estateID);
  4981. }
  4982. public void ReloadEstateData()
  4983. {
  4984. IEstateDataService estateDataService = EstateDataService;
  4985. if (estateDataService != null)
  4986. {
  4987. RegionInfo.EstateSettings = estateDataService.LoadEstateSettings(RegionInfo.RegionID, false);
  4988. TriggerEstateSunUpdate();
  4989. }
  4990. }
  4991. public void TriggerEstateSunUpdate()
  4992. {
  4993. EventManager.TriggerEstateToolsSunUpdate(RegionInfo.RegionHandle);
  4994. }
  4995. private void HandleReloadEstate(string module, string[] cmd)
  4996. {
  4997. if (MainConsole.Instance.ConsoleScene == null ||
  4998. (MainConsole.Instance.ConsoleScene is Scene &&
  4999. (Scene)MainConsole.Instance.ConsoleScene == this))
  5000. {
  5001. ReloadEstateData();
  5002. }
  5003. }
  5004. /// <summary>
  5005. /// Get the volume of space that will encompass all the given objects.
  5006. /// </summary>
  5007. /// <param name="objects"></param>
  5008. /// <param name="minX"></param>
  5009. /// <param name="maxX"></param>
  5010. /// <param name="minY"></param>
  5011. /// <param name="maxY"></param>
  5012. /// <param name="minZ"></param>
  5013. /// <param name="maxZ"></param>
  5014. /// <returns></returns>
  5015. public static Vector3[] GetCombinedBoundingBox(
  5016. List<SceneObjectGroup> objects,
  5017. out float minX, out float maxX, out float minY, out float maxY, out float minZ, out float maxZ)
  5018. {
  5019. minX = float.MaxValue;
  5020. maxX = float.MinValue;
  5021. minY = float.MaxValue;
  5022. maxY = float.MinValue;
  5023. minZ = float.MaxValue;
  5024. maxZ = float.MinValue;
  5025. List<Vector3> offsets = new List<Vector3>();
  5026. foreach (SceneObjectGroup g in objects)
  5027. {
  5028. float ominX, ominY, ominZ, omaxX, omaxY, omaxZ;
  5029. Vector3 vec = g.AbsolutePosition;
  5030. g.GetAxisAlignedBoundingBoxRaw(out ominX, out omaxX, out ominY, out omaxY, out ominZ, out omaxZ);
  5031. // m_log.DebugFormat(
  5032. // "[SCENE]: For {0} found AxisAlignedBoundingBoxRaw {1}, {2}",
  5033. // g.Name, new Vector3(ominX, ominY, ominZ), new Vector3(omaxX, omaxY, omaxZ));
  5034. ominX += vec.X;
  5035. omaxX += vec.X;
  5036. ominY += vec.Y;
  5037. omaxY += vec.Y;
  5038. ominZ += vec.Z;
  5039. omaxZ += vec.Z;
  5040. if (minX > ominX)
  5041. minX = ominX;
  5042. if (minY > ominY)
  5043. minY = ominY;
  5044. if (minZ > ominZ)
  5045. minZ = ominZ;
  5046. if (maxX < omaxX)
  5047. maxX = omaxX;
  5048. if (maxY < omaxY)
  5049. maxY = omaxY;
  5050. if (maxZ < omaxZ)
  5051. maxZ = omaxZ;
  5052. }
  5053. foreach (SceneObjectGroup g in objects)
  5054. {
  5055. Vector3 vec = g.AbsolutePosition;
  5056. vec.X -= minX;
  5057. vec.Y -= minY;
  5058. vec.Z -= minZ;
  5059. offsets.Add(vec);
  5060. }
  5061. return offsets.ToArray();
  5062. }
  5063. /// <summary>
  5064. /// Regenerate the maptile for this scene.
  5065. /// </summary>
  5066. /// <param name="sender"></param>
  5067. /// <param name="e"></param>
  5068. private void RegenerateMaptile()
  5069. {
  5070. IWorldMapModule mapModule = RequestModuleInterface<IWorldMapModule>();
  5071. if (mapModule != null)
  5072. mapModule.GenerateMaptile();
  5073. }
  5074. // public void CleanDroppedAttachments()
  5075. // {
  5076. // List<SceneObjectGroup> objectsToDelete =
  5077. // new List<SceneObjectGroup>();
  5078. //
  5079. // lock (m_cleaningAttachments)
  5080. // {
  5081. // ForEachSOG(delegate (SceneObjectGroup grp)
  5082. // {
  5083. // if (grp.RootPart.Shape.PCode == 0 && grp.RootPart.Shape.State != 0 && (!objectsToDelete.Contains(grp)))
  5084. // {
  5085. // UUID agentID = grp.OwnerID;
  5086. // if (agentID == UUID.Zero)
  5087. // {
  5088. // objectsToDelete.Add(grp);
  5089. // return;
  5090. // }
  5091. //
  5092. // ScenePresence sp = GetScenePresence(agentID);
  5093. // if (sp == null)
  5094. // {
  5095. // objectsToDelete.Add(grp);
  5096. // return;
  5097. // }
  5098. // }
  5099. // });
  5100. // }
  5101. //
  5102. // foreach (SceneObjectGroup grp in objectsToDelete)
  5103. // {
  5104. // m_log.InfoFormat("[SCENE]: Deleting dropped attachment {0} of user {1}", grp.UUID, grp.OwnerID);
  5105. // DeleteSceneObject(grp, true);
  5106. // }
  5107. // }
  5108. public void ThreadAlive(int threadCode)
  5109. {
  5110. switch(threadCode)
  5111. {
  5112. case 1: // Incoming
  5113. m_lastIncoming = Util.EnvironmentTickCount();
  5114. break;
  5115. case 2: // Incoming
  5116. m_lastOutgoing = Util.EnvironmentTickCount();
  5117. break;
  5118. }
  5119. }
  5120. public void RegenerateMaptileAndReregister(object sender, ElapsedEventArgs e)
  5121. {
  5122. RegenerateMaptile();
  5123. // We need to propagate the new image UUID to the grid service
  5124. // so that all simulators can retrieve it
  5125. string error = GridService.RegisterRegion(RegionInfo.ScopeID, new GridRegion(RegionInfo));
  5126. if (error != string.Empty)
  5127. throw new Exception(error);
  5128. }
  5129. /// <summary>
  5130. /// This method is called across the simulation connector to
  5131. /// determine if a given agent is allowed in this region
  5132. /// AS A ROOT AGENT
  5133. /// </summary>
  5134. /// <remarks>
  5135. /// Returning false here will prevent them
  5136. /// from logging into the region, teleporting into the region
  5137. /// or corssing the broder walking, but will NOT prevent
  5138. /// child agent creation, thereby emulating the SL behavior.
  5139. /// </remarks>
  5140. /// <param name='agentID'>The visitor's User ID</param>
  5141. /// <param name="agentHomeURI">The visitor's Home URI (may be null)</param>
  5142. /// <param name='position'></param>
  5143. /// <param name='reason'></param>
  5144. /// <returns></returns>
  5145. public bool QueryAccess(UUID agentID, string agentHomeURI, bool viaTeleport, Vector3 position, List<UUID> features, out string reason)
  5146. {
  5147. reason = string.Empty;
  5148. if (Permissions.IsGod(agentID))
  5149. return true;
  5150. if (!AllowAvatarCrossing && !viaTeleport)
  5151. {
  5152. reason = "Region Crossing not allowed";
  5153. return false;
  5154. }
  5155. bool isAdmin = Permissions.IsAdministrator(agentID);
  5156. bool isManager = Permissions.IsEstateManager(agentID);
  5157. // FIXME: Root agent count is currently known to be inaccurate. This forces a recount before we check.
  5158. // However, the long term fix is to make sure root agent count is always accurate.
  5159. m_sceneGraph.RecalculateStats();
  5160. int num = m_sceneGraph.GetRootAgentCount();
  5161. if (num >= RegionInfo.RegionSettings.AgentLimit)
  5162. {
  5163. if (!(isAdmin || isManager))
  5164. {
  5165. reason = "The region is full";
  5166. m_log.DebugFormat(
  5167. "[SCENE]: Denying presence with id {0} entry into {1} since region is at agent limit of {2}",
  5168. agentID, RegionInfo.RegionName, RegionInfo.RegionSettings.AgentLimit);
  5169. return false;
  5170. }
  5171. }
  5172. ScenePresence presence = GetScenePresence(agentID);
  5173. IClientAPI client = null;
  5174. AgentCircuitData aCircuit = null;
  5175. if (presence != null)
  5176. {
  5177. client = presence.ControllingClient;
  5178. if (client != null)
  5179. aCircuit = client.RequestClientInfo();
  5180. }
  5181. // We may be called before there is a presence or a client.
  5182. // Fake AgentCircuitData to keep IAuthorizationModule smiling
  5183. if (client == null)
  5184. {
  5185. aCircuit = new AgentCircuitData();
  5186. aCircuit.AgentID = agentID;
  5187. aCircuit.firstname = String.Empty;
  5188. aCircuit.lastname = String.Empty;
  5189. }
  5190. try
  5191. {
  5192. if (!AuthorizeUser(aCircuit, false, out reason))
  5193. {
  5194. //m_log.DebugFormat("[SCENE]: Denying access for {0}", agentID);
  5195. // reason = "Region authorization fail";
  5196. return false;
  5197. }
  5198. }
  5199. catch (Exception e)
  5200. {
  5201. m_log.DebugFormat("[SCENE]: Exception authorizing agent: {0} " + e.StackTrace, e.Message);
  5202. reason = "Error authorizing agent: " + e.Message;
  5203. return false;
  5204. }
  5205. // last check aditional land access restrictions and relocations
  5206. // if crossing (viaTeleport false) check only the specified parcel
  5207. return CheckLandPositionAccess(agentID, viaTeleport, true, position, out reason);
  5208. }
  5209. // check access to land.
  5210. public bool CheckLandPositionAccess(UUID agentID, bool NotCrossing, bool checkTeleHub, Vector3 position, out string reason)
  5211. {
  5212. reason = string.Empty;
  5213. if (Permissions.IsGod(agentID))
  5214. return true;
  5215. // Permissions.IsAdministrator is the same as IsGod for now
  5216. // bool isAdmin = Permissions.IsAdministrator(agentID);
  5217. // if(isAdmin)
  5218. // return true;
  5219. // also honor estate managers access rights
  5220. bool isManager = Permissions.IsEstateManager(agentID);
  5221. if(isManager)
  5222. return true;
  5223. if (NotCrossing)
  5224. {
  5225. if (!RegionInfo.EstateSettings.AllowDirectTeleport)
  5226. {
  5227. SceneObjectGroup telehub;
  5228. if (RegionInfo.RegionSettings.TelehubObject != UUID.Zero && (telehub = GetSceneObjectGroup (RegionInfo.RegionSettings.TelehubObject)) != null && checkTeleHub)
  5229. {
  5230. bool banned = true;
  5231. bool validTelehub = false;
  5232. List<SpawnPoint> spawnPoints = RegionInfo.RegionSettings.SpawnPoints();
  5233. Vector3 spawnPoint;
  5234. ILandObject land = null;
  5235. Vector3 telehubPosition = telehub.AbsolutePosition;
  5236. if(spawnPoints.Count == 0)
  5237. {
  5238. // will this ever happen?
  5239. // if so use the telehub object position
  5240. spawnPoint = telehubPosition;
  5241. land = LandChannel.GetLandObject(spawnPoint.X, spawnPoint.Y);
  5242. if(land != null && !land.IsEitherBannedOrRestricted(agentID))
  5243. {
  5244. banned = false;
  5245. validTelehub = true;
  5246. }
  5247. }
  5248. else
  5249. {
  5250. Quaternion telehubRotation = telehub.GroupRotation;
  5251. foreach (SpawnPoint spawn in spawnPoints)
  5252. {
  5253. spawnPoint = spawn.GetLocation(telehubPosition, telehubRotation);
  5254. land = LandChannel.GetLandObject(spawnPoint.X, spawnPoint.Y);
  5255. if (land == null)
  5256. continue;
  5257. validTelehub = true;
  5258. if (!land.IsEitherBannedOrRestricted(agentID))
  5259. {
  5260. banned = false;
  5261. break;
  5262. }
  5263. }
  5264. }
  5265. if(validTelehub)
  5266. {
  5267. if (banned)
  5268. {
  5269. reason = "No suitable landing point found";
  5270. return false;
  5271. }
  5272. else
  5273. return true;
  5274. }
  5275. // possible broken telehub, fall into normal check
  5276. }
  5277. }
  5278. float posX = position.X;
  5279. float posY = position.Y;
  5280. // allow position relocation
  5281. if (!TestLandRestrictions(agentID, out reason, ref posX, ref posY))
  5282. {
  5283. // m_log.DebugFormat("[SCENE]: Denying {0} because they are banned on all parcels", agentID);
  5284. reason = "You dont have access to the region parcels";
  5285. return false;
  5286. }
  5287. }
  5288. else // check for query region crossing only
  5289. {
  5290. // no relocation allowed on crossings
  5291. ILandObject land = LandChannel.GetLandObject(position.X, position.Y);
  5292. if (land == null)
  5293. {
  5294. reason = "No parcel found";
  5295. return false;
  5296. }
  5297. bool banned = land.IsBannedFromLand(agentID);
  5298. bool restricted = land.IsRestrictedFromLand(agentID);
  5299. if (banned || restricted)
  5300. {
  5301. if (banned)
  5302. reason = "You are banned from the parcel";
  5303. else
  5304. reason = "The parcel is restricted";
  5305. return false;
  5306. }
  5307. }
  5308. return true;
  5309. }
  5310. public void StartTimerWatchdog()
  5311. {
  5312. m_timerWatchdog.Interval = 1000;
  5313. m_timerWatchdog.Elapsed += TimerWatchdog;
  5314. m_timerWatchdog.AutoReset = true;
  5315. m_timerWatchdog.Start();
  5316. }
  5317. public void TimerWatchdog(object sender, ElapsedEventArgs e)
  5318. {
  5319. CheckHeartbeat();
  5320. IEtcdModule etcd = RequestModuleInterface<IEtcdModule>();
  5321. int flags;
  5322. string message;
  5323. if (etcd != null)
  5324. {
  5325. int health = GetHealth(out flags, out message);
  5326. if (health != m_lastHealth)
  5327. {
  5328. m_lastHealth = health;
  5329. etcd.Store("Health", health.ToString(), 300000);
  5330. etcd.Store("HealthFlags", flags.ToString(), 300000);
  5331. }
  5332. int roots = 0;
  5333. foreach (ScenePresence sp in GetScenePresences())
  5334. if (!sp.IsChildAgent && !sp.IsNPC)
  5335. roots++;
  5336. if (m_lastUsers != roots)
  5337. {
  5338. m_lastUsers = roots;
  5339. etcd.Store("RootAgents", roots.ToString(), 300000);
  5340. }
  5341. }
  5342. }
  5343. /// This method deals with movement when an avatar is automatically moving (but this is distinct from the
  5344. /// autopilot that moves an avatar to a sit target!.
  5345. /// </summary>
  5346. /// <remarks>
  5347. /// This is not intended as a permament location for this method.
  5348. /// </remarks>
  5349. /// <param name="presence"></param>
  5350. /* move to target is now done on presence update
  5351. private void HandleOnSignificantClientMovement(ScenePresence presence)
  5352. {
  5353. if (presence.MovingToTarget)
  5354. {
  5355. double distanceToTarget = Util.GetDistanceTo(presence.AbsolutePosition, presence.MoveToPositionTarget);
  5356. // m_log.DebugFormat(
  5357. // "[SCENE]: Abs pos of {0} is {1}, target {2}, distance {3}",
  5358. // presence.Name, presence.AbsolutePosition, presence.MoveToPositionTarget, distanceToTarget);
  5359. // Check the error term of the current position in relation to the target position
  5360. if (distanceToTarget <= ScenePresence.SIGNIFICANT_MOVEMENT)
  5361. {
  5362. // We are close enough to the target
  5363. // m_log.DebugFormat("[SCENEE]: Stopping autopilot of {0}", presence.Name);
  5364. presence.Velocity = Vector3.Zero;
  5365. presence.AbsolutePosition = presence.MoveToPositionTarget;
  5366. presence.ResetMoveToTarget();
  5367. if (presence.Flying)
  5368. {
  5369. // A horrible hack to stop the avatar dead in its tracks rather than having them overshoot
  5370. // the target if flying.
  5371. // We really need to be more subtle (slow the avatar as it approaches the target) or at
  5372. // least be able to set collision status once, rather than 5 times to give it enough
  5373. // weighting so that that PhysicsActor thinks it really is colliding.
  5374. for (int i = 0; i < 5; i++)
  5375. presence.IsColliding = true;
  5376. if (presence.LandAtTarget)
  5377. presence.Flying = false;
  5378. // Vector3 targetPos = presence.MoveToPositionTarget;
  5379. // float terrainHeight = (float)presence.Scene.Heightmap[(int)targetPos.X, (int)targetPos.Y];
  5380. // if (targetPos.Z - terrainHeight < 0.2)
  5381. // {
  5382. // presence.Flying = false;
  5383. // }
  5384. }
  5385. // m_log.DebugFormat(
  5386. // "[SCENE]: AgentControlFlags {0}, MovementFlag {1} for {2}",
  5387. // presence.AgentControlFlags, presence.MovementFlag, presence.Name);
  5388. }
  5389. else
  5390. {
  5391. // m_log.DebugFormat(
  5392. // "[SCENE]: Updating npc {0} at {1} for next movement to {2}",
  5393. // presence.Name, presence.AbsolutePosition, presence.MoveToPositionTarget);
  5394. Vector3 agent_control_v3 = new Vector3();
  5395. presence.HandleMoveToTargetUpdate(1, ref agent_control_v3);
  5396. presence.AddNewMovement(agent_control_v3);
  5397. }
  5398. }
  5399. }
  5400. */
  5401. // manage and select spawn points in sequence
  5402. public int SpawnPoint()
  5403. {
  5404. int spawnpoints = RegionInfo.RegionSettings.SpawnPoints().Count;
  5405. if (spawnpoints == 0)
  5406. return 0;
  5407. m_SpawnPoint++;
  5408. if (m_SpawnPoint > spawnpoints)
  5409. m_SpawnPoint = 1;
  5410. return m_SpawnPoint - 1;
  5411. }
  5412. private void HandleGcCollect(string module, string[] args)
  5413. {
  5414. GC.Collect();
  5415. }
  5416. /// <summary>
  5417. /// Wrappers to get physics modules retrieve assets.
  5418. /// </summary>
  5419. /// <remarks>
  5420. /// Has to be done this way
  5421. /// because we can't assign the asset service to physics directly - at the
  5422. /// time physics are instantiated it's not registered but it will be by
  5423. /// the time the first prim exists.
  5424. /// </remarks>
  5425. /// <param name="assetID"></param>
  5426. /// <param name="callback"></param>
  5427. public void PhysicsRequestAsset(UUID assetID, AssetReceivedDelegate callback)
  5428. {
  5429. AssetService.Get(assetID.ToString(), callback, PhysicsAssetReceived);
  5430. }
  5431. private void PhysicsAssetReceived(string id, Object sender, AssetBase asset)
  5432. {
  5433. AssetReceivedDelegate callback = (AssetReceivedDelegate)sender;
  5434. callback(asset);
  5435. }
  5436. public string GetExtraSetting(string name)
  5437. {
  5438. if (m_extraSettings == null)
  5439. return String.Empty;
  5440. string val;
  5441. if (!m_extraSettings.TryGetValue(name, out val))
  5442. return String.Empty;
  5443. return val;
  5444. }
  5445. public void StoreExtraSetting(string name, string val)
  5446. {
  5447. if (m_extraSettings == null)
  5448. return;
  5449. string oldVal;
  5450. if (m_extraSettings.TryGetValue(name, out oldVal))
  5451. {
  5452. if (oldVal == val)
  5453. return;
  5454. }
  5455. m_extraSettings[name] = val;
  5456. m_SimulationDataService.SaveExtra(RegionInfo.RegionID, name, val);
  5457. m_eventManager.TriggerExtraSettingChanged(this, name, val);
  5458. }
  5459. public void RemoveExtraSetting(string name)
  5460. {
  5461. if (m_extraSettings == null)
  5462. return;
  5463. if (!m_extraSettings.ContainsKey(name))
  5464. return;
  5465. m_extraSettings.Remove(name);
  5466. m_SimulationDataService.RemoveExtra(RegionInfo.RegionID, name);
  5467. m_eventManager.TriggerExtraSettingChanged(this, name, String.Empty);
  5468. }
  5469. public bool InTeleportTargetsCoolDown(UUID sourceID, UUID targetID, double timeout)
  5470. {
  5471. lock(TeleportTargetsCoolDown)
  5472. {
  5473. UUID lastSource = UUID.Zero;
  5474. TeleportTargetsCoolDown.TryGetValue(targetID, out lastSource);
  5475. if(lastSource == UUID.Zero)
  5476. {
  5477. TeleportTargetsCoolDown.Add(targetID, sourceID, timeout);
  5478. return false;
  5479. }
  5480. TeleportTargetsCoolDown.AddOrUpdate(targetID, sourceID, timeout);
  5481. return lastSource == sourceID;
  5482. }
  5483. }
  5484. }
  5485. }