1
0

PrimitiveBaseShape.cs 46 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531
  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.Drawing;
  30. using System.Drawing.Imaging;
  31. using System.IO;
  32. using System.Reflection;
  33. using System.Xml;
  34. using System.Xml.Schema;
  35. using System.Xml.Serialization;
  36. using log4net;
  37. using OpenMetaverse;
  38. using OpenMetaverse.StructuredData;
  39. namespace OpenSim.Framework
  40. {
  41. public enum ProfileShape : byte
  42. {
  43. Circle = 0,
  44. Square = 1,
  45. IsometricTriangle = 2,
  46. EquilateralTriangle = 3,
  47. RightTriangle = 4,
  48. HalfCircle = 5
  49. }
  50. public enum HollowShape : byte
  51. {
  52. Same = 0,
  53. Circle = 16,
  54. Square = 32,
  55. Triangle = 48
  56. }
  57. public enum PCodeEnum : byte
  58. {
  59. Primitive = 9,
  60. Avatar = 47,
  61. Grass = 95,
  62. NewTree = 111,
  63. ParticleSystem = 143,
  64. Tree = 255
  65. }
  66. public enum Extrusion : byte
  67. {
  68. Straight = 16,
  69. Curve1 = 32,
  70. Curve2 = 48,
  71. Flexible = 128
  72. }
  73. [Serializable]
  74. public class PrimitiveBaseShape
  75. {
  76. private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  77. private static readonly byte[] DEFAULT_TEXTURE = new Primitive.TextureEntry(new UUID("89556747-24cb-43ed-920b-47caed15465f")).GetBytes();
  78. private byte[] m_textureEntry;
  79. private ushort _pathBegin;
  80. private byte _pathCurve;
  81. private ushort _pathEnd;
  82. private sbyte _pathRadiusOffset;
  83. private byte _pathRevolutions;
  84. private byte _pathScaleX;
  85. private byte _pathScaleY;
  86. private byte _pathShearX;
  87. private byte _pathShearY;
  88. private sbyte _pathSkew;
  89. private sbyte _pathTaperX;
  90. private sbyte _pathTaperY;
  91. private sbyte _pathTwist;
  92. private sbyte _pathTwistBegin;
  93. private byte _pCode;
  94. private ushort _profileBegin;
  95. private ushort _profileEnd;
  96. private ushort _profileHollow;
  97. private Vector3 _scale;
  98. private byte _state;
  99. private byte _lastattach;
  100. private ProfileShape _profileShape;
  101. private HollowShape _hollowShape;
  102. // Sculpted
  103. [XmlIgnore] private UUID _sculptTexture;
  104. [XmlIgnore] private byte _sculptType;
  105. [XmlIgnore] private byte[] _sculptData = Utils.EmptyBytes;
  106. // Flexi
  107. [XmlIgnore] private int _flexiSoftness;
  108. [XmlIgnore] private float _flexiTension;
  109. [XmlIgnore] private float _flexiDrag;
  110. [XmlIgnore] private float _flexiGravity;
  111. [XmlIgnore] private float _flexiWind;
  112. [XmlIgnore] private float _flexiForceX;
  113. [XmlIgnore] private float _flexiForceY;
  114. [XmlIgnore] private float _flexiForceZ;
  115. //Bright n sparkly
  116. [XmlIgnore] private float _lightColorR;
  117. [XmlIgnore] private float _lightColorG;
  118. [XmlIgnore] private float _lightColorB;
  119. [XmlIgnore] private float _lightColorA = 1.0f;
  120. [XmlIgnore] private float _lightRadius;
  121. [XmlIgnore] private float _lightCutoff;
  122. [XmlIgnore] private float _lightFalloff;
  123. [XmlIgnore] private float _lightIntensity = 1.0f;
  124. [XmlIgnore] private bool _flexiEntry;
  125. [XmlIgnore] private bool _lightEntry;
  126. [XmlIgnore] private bool _sculptEntry;
  127. // Light Projection Filter
  128. [XmlIgnore] private bool _projectionEntry;
  129. [XmlIgnore] private UUID _projectionTextureID;
  130. [XmlIgnore] private float _projectionFOV;
  131. [XmlIgnore] private float _projectionFocus;
  132. [XmlIgnore] private float _projectionAmb;
  133. public byte ProfileCurve
  134. {
  135. get { return (byte)((byte)HollowShape | (byte)ProfileShape); }
  136. set
  137. {
  138. // Handle hollow shape component
  139. byte hollowShapeByte = (byte)(value & 0xf0);
  140. if (!Enum.IsDefined(typeof(HollowShape), hollowShapeByte))
  141. {
  142. m_log.WarnFormat(
  143. "[SHAPE]: Attempt to set a ProfileCurve with a hollow shape value of {0}, which isn't a valid enum. Replacing with default shape.",
  144. hollowShapeByte);
  145. this._hollowShape = HollowShape.Same;
  146. }
  147. else
  148. {
  149. this._hollowShape = (HollowShape)hollowShapeByte;
  150. }
  151. // Handle profile shape component
  152. byte profileShapeByte = (byte)(value & 0xf);
  153. if (!Enum.IsDefined(typeof(ProfileShape), profileShapeByte))
  154. {
  155. m_log.WarnFormat(
  156. "[SHAPE]: Attempt to set a ProfileCurve with a profile shape value of {0}, which isn't a valid enum. Replacing with square.",
  157. profileShapeByte);
  158. this._profileShape = ProfileShape.Square;
  159. }
  160. else
  161. {
  162. this._profileShape = (ProfileShape)profileShapeByte;
  163. }
  164. }
  165. }
  166. /// <summary>
  167. /// Entries to store media textures on each face
  168. /// </summary>
  169. /// Do not change this value directly - always do it through an IMoapModule.
  170. /// Lock before manipulating.
  171. public MediaList Media { get; set; }
  172. public PrimitiveBaseShape()
  173. {
  174. PCode = (byte)PCodeEnum.Primitive;
  175. m_textureEntry = DEFAULT_TEXTURE;
  176. }
  177. /// <summary>
  178. /// Construct a PrimitiveBaseShape object from a OpenMetaverse.Primitive object
  179. /// </summary>
  180. /// <param name="prim"></param>
  181. public PrimitiveBaseShape(Primitive prim)
  182. {
  183. // m_log.DebugFormat("[PRIMITIVE BASE SHAPE]: Creating from {0}", prim.ID);
  184. PCode = (byte)prim.PrimData.PCode;
  185. State = prim.PrimData.State;
  186. LastAttachPoint = prim.PrimData.State;
  187. PathBegin = Primitive.PackBeginCut(prim.PrimData.PathBegin);
  188. PathEnd = Primitive.PackEndCut(prim.PrimData.PathEnd);
  189. PathScaleX = Primitive.PackPathScale(prim.PrimData.PathScaleX);
  190. PathScaleY = Primitive.PackPathScale(prim.PrimData.PathScaleY);
  191. PathShearX = (byte)Primitive.PackPathShear(prim.PrimData.PathShearX);
  192. PathShearY = (byte)Primitive.PackPathShear(prim.PrimData.PathShearY);
  193. PathSkew = Primitive.PackPathTwist(prim.PrimData.PathSkew);
  194. ProfileBegin = Primitive.PackBeginCut(prim.PrimData.ProfileBegin);
  195. ProfileEnd = Primitive.PackEndCut(prim.PrimData.ProfileEnd);
  196. Scale = prim.Scale;
  197. PathCurve = (byte)prim.PrimData.PathCurve;
  198. ProfileCurve = (byte)prim.PrimData.ProfileCurve;
  199. ProfileHollow = Primitive.PackProfileHollow(prim.PrimData.ProfileHollow);
  200. PathRadiusOffset = Primitive.PackPathTwist(prim.PrimData.PathRadiusOffset);
  201. PathRevolutions = Primitive.PackPathRevolutions(prim.PrimData.PathRevolutions);
  202. PathTaperX = Primitive.PackPathTaper(prim.PrimData.PathTaperX);
  203. PathTaperY = Primitive.PackPathTaper(prim.PrimData.PathTaperY);
  204. PathTwist = Primitive.PackPathTwist(prim.PrimData.PathTwist);
  205. PathTwistBegin = Primitive.PackPathTwist(prim.PrimData.PathTwistBegin);
  206. m_textureEntry = prim.Textures.GetBytes();
  207. if (prim.Sculpt != null)
  208. {
  209. SculptEntry = (prim.Sculpt.Type != OpenMetaverse.SculptType.None);
  210. SculptData = prim.Sculpt.GetBytes();
  211. SculptTexture = prim.Sculpt.SculptTexture;
  212. SculptType = (byte)prim.Sculpt.Type;
  213. }
  214. else
  215. {
  216. SculptType = (byte)OpenMetaverse.SculptType.None;
  217. }
  218. }
  219. [XmlIgnore]
  220. public Primitive.TextureEntry Textures
  221. {
  222. get
  223. {
  224. // m_log.DebugFormat("[SHAPE]: get m_textureEntry length {0}", m_textureEntry.Length);
  225. try { return new Primitive.TextureEntry(m_textureEntry, 0, m_textureEntry.Length); }
  226. catch { }
  227. m_log.Warn("[SHAPE]: Failed to decode texture, length=" + ((m_textureEntry != null) ? m_textureEntry.Length : 0));
  228. return new Primitive.TextureEntry(UUID.Zero);
  229. }
  230. set { m_textureEntry = value.GetBytes(); }
  231. }
  232. public byte[] TextureEntry
  233. {
  234. get { return m_textureEntry; }
  235. set
  236. {
  237. if (value == null)
  238. m_textureEntry = new byte[1];
  239. else
  240. m_textureEntry = value;
  241. }
  242. }
  243. public static PrimitiveBaseShape Default
  244. {
  245. get
  246. {
  247. PrimitiveBaseShape boxShape = CreateBox();
  248. boxShape.SetScale(0.5f);
  249. return boxShape;
  250. }
  251. }
  252. public static PrimitiveBaseShape Create()
  253. {
  254. PrimitiveBaseShape shape = new PrimitiveBaseShape();
  255. return shape;
  256. }
  257. public static PrimitiveBaseShape CreateBox()
  258. {
  259. PrimitiveBaseShape shape = Create();
  260. shape._pathCurve = (byte) Extrusion.Straight;
  261. shape._profileShape = ProfileShape.Square;
  262. shape._pathScaleX = 100;
  263. shape._pathScaleY = 100;
  264. return shape;
  265. }
  266. public static PrimitiveBaseShape CreateSphere()
  267. {
  268. PrimitiveBaseShape shape = Create();
  269. shape._pathCurve = (byte) Extrusion.Curve1;
  270. shape._profileShape = ProfileShape.HalfCircle;
  271. shape._pathScaleX = 100;
  272. shape._pathScaleY = 100;
  273. return shape;
  274. }
  275. public static PrimitiveBaseShape CreateCylinder()
  276. {
  277. PrimitiveBaseShape shape = Create();
  278. shape._pathCurve = (byte) Extrusion.Curve1;
  279. shape._profileShape = ProfileShape.Square;
  280. shape._pathScaleX = 100;
  281. shape._pathScaleY = 100;
  282. return shape;
  283. }
  284. public void SetScale(float side)
  285. {
  286. _scale = new Vector3(side, side, side);
  287. }
  288. public void SetHeigth(float height)
  289. {
  290. _scale.Z = height;
  291. }
  292. public void SetRadius(float radius)
  293. {
  294. _scale.X = _scale.Y = radius * 2f;
  295. }
  296. // TODO: void returns need to change of course
  297. public virtual void GetMesh()
  298. {
  299. }
  300. public PrimitiveBaseShape Copy()
  301. {
  302. return (PrimitiveBaseShape) MemberwiseClone();
  303. }
  304. public static PrimitiveBaseShape CreateCylinder(float radius, float heigth)
  305. {
  306. PrimitiveBaseShape shape = CreateCylinder();
  307. shape.SetHeigth(heigth);
  308. shape.SetRadius(radius);
  309. return shape;
  310. }
  311. public void SetPathRange(Vector3 pathRange)
  312. {
  313. _pathBegin = Primitive.PackBeginCut(pathRange.X);
  314. _pathEnd = Primitive.PackEndCut(pathRange.Y);
  315. }
  316. public void SetPathRange(float begin, float end)
  317. {
  318. _pathBegin = Primitive.PackBeginCut(begin);
  319. _pathEnd = Primitive.PackEndCut(end);
  320. }
  321. public void SetSculptProperties(byte sculptType, UUID SculptTextureUUID)
  322. {
  323. _sculptType = sculptType;
  324. _sculptTexture = SculptTextureUUID;
  325. }
  326. public void SetProfileRange(Vector3 profileRange)
  327. {
  328. _profileBegin = Primitive.PackBeginCut(profileRange.X);
  329. _profileEnd = Primitive.PackEndCut(profileRange.Y);
  330. }
  331. public void SetProfileRange(float begin, float end)
  332. {
  333. _profileBegin = Primitive.PackBeginCut(begin);
  334. _profileEnd = Primitive.PackEndCut(end);
  335. }
  336. public byte[] ExtraParams
  337. {
  338. get
  339. {
  340. return ExtraParamsToBytes();
  341. }
  342. set
  343. {
  344. ReadInExtraParamsBytes(value);
  345. }
  346. }
  347. public ushort PathBegin {
  348. get {
  349. return _pathBegin;
  350. }
  351. set {
  352. _pathBegin = value;
  353. }
  354. }
  355. public byte PathCurve {
  356. get {
  357. return _pathCurve;
  358. }
  359. set {
  360. _pathCurve = value;
  361. }
  362. }
  363. public ushort PathEnd {
  364. get {
  365. return _pathEnd;
  366. }
  367. set {
  368. _pathEnd = value;
  369. }
  370. }
  371. public sbyte PathRadiusOffset {
  372. get {
  373. return _pathRadiusOffset;
  374. }
  375. set {
  376. _pathRadiusOffset = value;
  377. }
  378. }
  379. public byte PathRevolutions {
  380. get {
  381. return _pathRevolutions;
  382. }
  383. set {
  384. _pathRevolutions = value;
  385. }
  386. }
  387. public byte PathScaleX {
  388. get {
  389. return _pathScaleX;
  390. }
  391. set {
  392. _pathScaleX = value;
  393. }
  394. }
  395. public byte PathScaleY {
  396. get {
  397. return _pathScaleY;
  398. }
  399. set {
  400. _pathScaleY = value;
  401. }
  402. }
  403. public byte PathShearX {
  404. get {
  405. return _pathShearX;
  406. }
  407. set {
  408. _pathShearX = value;
  409. }
  410. }
  411. public byte PathShearY {
  412. get {
  413. return _pathShearY;
  414. }
  415. set {
  416. _pathShearY = value;
  417. }
  418. }
  419. public sbyte PathSkew {
  420. get {
  421. return _pathSkew;
  422. }
  423. set {
  424. _pathSkew = value;
  425. }
  426. }
  427. public sbyte PathTaperX {
  428. get {
  429. return _pathTaperX;
  430. }
  431. set {
  432. _pathTaperX = value;
  433. }
  434. }
  435. public sbyte PathTaperY {
  436. get {
  437. return _pathTaperY;
  438. }
  439. set {
  440. _pathTaperY = value;
  441. }
  442. }
  443. public sbyte PathTwist {
  444. get {
  445. return _pathTwist;
  446. }
  447. set {
  448. _pathTwist = value;
  449. }
  450. }
  451. public sbyte PathTwistBegin {
  452. get {
  453. return _pathTwistBegin;
  454. }
  455. set {
  456. _pathTwistBegin = value;
  457. }
  458. }
  459. public byte PCode {
  460. get {
  461. return _pCode;
  462. }
  463. set {
  464. _pCode = value;
  465. }
  466. }
  467. public ushort ProfileBegin {
  468. get {
  469. return _profileBegin;
  470. }
  471. set {
  472. _profileBegin = value;
  473. }
  474. }
  475. public ushort ProfileEnd {
  476. get {
  477. return _profileEnd;
  478. }
  479. set {
  480. _profileEnd = value;
  481. }
  482. }
  483. public ushort ProfileHollow {
  484. get {
  485. return _profileHollow;
  486. }
  487. set {
  488. _profileHollow = value;
  489. }
  490. }
  491. public Vector3 Scale {
  492. get {
  493. return _scale;
  494. }
  495. set {
  496. _scale = value;
  497. }
  498. }
  499. public byte State {
  500. get {
  501. return _state;
  502. }
  503. set {
  504. _state = value;
  505. }
  506. }
  507. public byte LastAttachPoint {
  508. get {
  509. return _lastattach;
  510. }
  511. set {
  512. _lastattach = value;
  513. }
  514. }
  515. public ProfileShape ProfileShape {
  516. get {
  517. return _profileShape;
  518. }
  519. set {
  520. _profileShape = value;
  521. }
  522. }
  523. public HollowShape HollowShape {
  524. get {
  525. return _hollowShape;
  526. }
  527. set {
  528. _hollowShape = value;
  529. }
  530. }
  531. public UUID SculptTexture {
  532. get {
  533. return _sculptTexture;
  534. }
  535. set {
  536. _sculptTexture = value;
  537. }
  538. }
  539. public byte SculptType
  540. {
  541. get
  542. {
  543. return _sculptType;
  544. }
  545. set
  546. {
  547. _sculptType = value;
  548. }
  549. }
  550. // This is only used at runtime. For sculpties this holds the texture data, and for meshes
  551. // the mesh data.
  552. public byte[] SculptData
  553. {
  554. get
  555. {
  556. return _sculptData;
  557. }
  558. set
  559. {
  560. // m_log.DebugFormat("[PRIMITIVE BASE SHAPE]: Setting SculptData to data with length {0}", value.Length);
  561. _sculptData = value;
  562. }
  563. }
  564. public int FlexiSoftness
  565. {
  566. get
  567. {
  568. return _flexiSoftness;
  569. }
  570. set
  571. {
  572. _flexiSoftness = value;
  573. }
  574. }
  575. public float FlexiTension {
  576. get {
  577. return _flexiTension;
  578. }
  579. set {
  580. _flexiTension = value;
  581. }
  582. }
  583. public float FlexiDrag {
  584. get {
  585. return _flexiDrag;
  586. }
  587. set {
  588. _flexiDrag = value;
  589. }
  590. }
  591. public float FlexiGravity {
  592. get {
  593. return _flexiGravity;
  594. }
  595. set {
  596. _flexiGravity = value;
  597. }
  598. }
  599. public float FlexiWind {
  600. get {
  601. return _flexiWind;
  602. }
  603. set {
  604. _flexiWind = value;
  605. }
  606. }
  607. public float FlexiForceX {
  608. get {
  609. return _flexiForceX;
  610. }
  611. set {
  612. _flexiForceX = value;
  613. }
  614. }
  615. public float FlexiForceY {
  616. get {
  617. return _flexiForceY;
  618. }
  619. set {
  620. _flexiForceY = value;
  621. }
  622. }
  623. public float FlexiForceZ {
  624. get {
  625. return _flexiForceZ;
  626. }
  627. set {
  628. _flexiForceZ = value;
  629. }
  630. }
  631. public float LightColorR {
  632. get {
  633. return _lightColorR;
  634. }
  635. set {
  636. _lightColorR = value;
  637. }
  638. }
  639. public float LightColorG {
  640. get {
  641. return _lightColorG;
  642. }
  643. set {
  644. _lightColorG = value;
  645. }
  646. }
  647. public float LightColorB {
  648. get {
  649. return _lightColorB;
  650. }
  651. set {
  652. _lightColorB = value;
  653. }
  654. }
  655. public float LightColorA {
  656. get {
  657. return _lightColorA;
  658. }
  659. set {
  660. _lightColorA = value;
  661. }
  662. }
  663. public float LightRadius {
  664. get {
  665. return _lightRadius;
  666. }
  667. set {
  668. _lightRadius = value;
  669. }
  670. }
  671. public float LightCutoff {
  672. get {
  673. return _lightCutoff;
  674. }
  675. set {
  676. _lightCutoff = value;
  677. }
  678. }
  679. public float LightFalloff {
  680. get {
  681. return _lightFalloff;
  682. }
  683. set {
  684. _lightFalloff = value;
  685. }
  686. }
  687. public float LightIntensity {
  688. get {
  689. return _lightIntensity;
  690. }
  691. set {
  692. _lightIntensity = value;
  693. }
  694. }
  695. public bool FlexiEntry {
  696. get {
  697. return _flexiEntry;
  698. }
  699. set {
  700. _flexiEntry = value;
  701. }
  702. }
  703. public bool LightEntry {
  704. get {
  705. return _lightEntry;
  706. }
  707. set {
  708. _lightEntry = value;
  709. }
  710. }
  711. public bool SculptEntry {
  712. get {
  713. return _sculptEntry;
  714. }
  715. set {
  716. _sculptEntry = value;
  717. }
  718. }
  719. public bool ProjectionEntry {
  720. get {
  721. return _projectionEntry;
  722. }
  723. set {
  724. _projectionEntry = value;
  725. }
  726. }
  727. public UUID ProjectionTextureUUID {
  728. get {
  729. return _projectionTextureID;
  730. }
  731. set {
  732. _projectionTextureID = value;
  733. }
  734. }
  735. public float ProjectionFOV {
  736. get {
  737. return _projectionFOV;
  738. }
  739. set {
  740. _projectionFOV = value;
  741. }
  742. }
  743. public float ProjectionFocus {
  744. get {
  745. return _projectionFocus;
  746. }
  747. set {
  748. _projectionFocus = value;
  749. }
  750. }
  751. public float ProjectionAmbiance {
  752. get {
  753. return _projectionAmb;
  754. }
  755. set {
  756. _projectionAmb = value;
  757. }
  758. }
  759. public ulong GetMeshKey(Vector3 size, float lod)
  760. {
  761. ulong hash = 5381;
  762. hash = djb2(hash, this.PathCurve);
  763. hash = djb2(hash, (byte)((byte)this.HollowShape | (byte)this.ProfileShape));
  764. hash = djb2(hash, this.PathBegin);
  765. hash = djb2(hash, this.PathEnd);
  766. hash = djb2(hash, this.PathScaleX);
  767. hash = djb2(hash, this.PathScaleY);
  768. hash = djb2(hash, this.PathShearX);
  769. hash = djb2(hash, this.PathShearY);
  770. hash = djb2(hash, (byte)this.PathTwist);
  771. hash = djb2(hash, (byte)this.PathTwistBegin);
  772. hash = djb2(hash, (byte)this.PathRadiusOffset);
  773. hash = djb2(hash, (byte)this.PathTaperX);
  774. hash = djb2(hash, (byte)this.PathTaperY);
  775. hash = djb2(hash, this.PathRevolutions);
  776. hash = djb2(hash, (byte)this.PathSkew);
  777. hash = djb2(hash, this.ProfileBegin);
  778. hash = djb2(hash, this.ProfileEnd);
  779. hash = djb2(hash, this.ProfileHollow);
  780. // TODO: Separate scale out from the primitive shape data (after
  781. // scaling is supported at the physics engine level)
  782. byte[] scaleBytes = size.GetBytes();
  783. for (int i = 0; i < scaleBytes.Length; i++)
  784. hash = djb2(hash, scaleBytes[i]);
  785. // Include LOD in hash, accounting for endianness
  786. byte[] lodBytes = new byte[4];
  787. Buffer.BlockCopy(BitConverter.GetBytes(lod), 0, lodBytes, 0, 4);
  788. if (!BitConverter.IsLittleEndian)
  789. {
  790. Array.Reverse(lodBytes, 0, 4);
  791. }
  792. for (int i = 0; i < lodBytes.Length; i++)
  793. hash = djb2(hash, lodBytes[i]);
  794. // include sculpt UUID
  795. if (this.SculptEntry)
  796. {
  797. scaleBytes = this.SculptTexture.GetBytes();
  798. for (int i = 0; i < scaleBytes.Length; i++)
  799. hash = djb2(hash, scaleBytes[i]);
  800. }
  801. return hash;
  802. }
  803. private ulong djb2(ulong hash, byte c)
  804. {
  805. return ((hash << 5) + hash) + (ulong)c;
  806. }
  807. private ulong djb2(ulong hash, ushort c)
  808. {
  809. hash = ((hash << 5) + hash) + (ulong)((byte)c);
  810. return ((hash << 5) + hash) + (ulong)(c >> 8);
  811. }
  812. public byte[] ExtraParamsToBytes()
  813. {
  814. // m_log.DebugFormat("[EXTRAPARAMS]: Called ExtraParamsToBytes()");
  815. ushort FlexiEP = 0x10;
  816. ushort LightEP = 0x20;
  817. ushort SculptEP = 0x30;
  818. ushort ProjectionEP = 0x40;
  819. int i = 0;
  820. uint TotalBytesLength = 1; // ExtraParamsNum
  821. uint ExtraParamsNum = 0;
  822. if (_flexiEntry)
  823. {
  824. ExtraParamsNum++;
  825. TotalBytesLength += 16;// data
  826. TotalBytesLength += 2 + 4; // type
  827. }
  828. if (_lightEntry)
  829. {
  830. ExtraParamsNum++;
  831. TotalBytesLength += 16;// data
  832. TotalBytesLength += 2 + 4; // type
  833. }
  834. if (_sculptEntry)
  835. {
  836. ExtraParamsNum++;
  837. TotalBytesLength += 17;// data
  838. TotalBytesLength += 2 + 4; // type
  839. }
  840. if (_projectionEntry)
  841. {
  842. ExtraParamsNum++;
  843. TotalBytesLength += 28;// data
  844. TotalBytesLength += 2 + 4;// type
  845. }
  846. byte[] returnbytes = new byte[TotalBytesLength];
  847. // uint paramlength = ExtraParamsNum;
  848. // Stick in the number of parameters
  849. returnbytes[i++] = (byte)ExtraParamsNum;
  850. if (_flexiEntry)
  851. {
  852. byte[] FlexiData = GetFlexiBytes();
  853. returnbytes[i++] = (byte)(FlexiEP % 256);
  854. returnbytes[i++] = (byte)((FlexiEP >> 8) % 256);
  855. returnbytes[i++] = (byte)(FlexiData.Length % 256);
  856. returnbytes[i++] = (byte)((FlexiData.Length >> 8) % 256);
  857. returnbytes[i++] = (byte)((FlexiData.Length >> 16) % 256);
  858. returnbytes[i++] = (byte)((FlexiData.Length >> 24) % 256);
  859. Array.Copy(FlexiData, 0, returnbytes, i, FlexiData.Length);
  860. i += FlexiData.Length;
  861. }
  862. if (_lightEntry)
  863. {
  864. byte[] LightData = GetLightBytes();
  865. returnbytes[i++] = (byte)(LightEP % 256);
  866. returnbytes[i++] = (byte)((LightEP >> 8) % 256);
  867. returnbytes[i++] = (byte)(LightData.Length % 256);
  868. returnbytes[i++] = (byte)((LightData.Length >> 8) % 256);
  869. returnbytes[i++] = (byte)((LightData.Length >> 16) % 256);
  870. returnbytes[i++] = (byte)((LightData.Length >> 24) % 256);
  871. Array.Copy(LightData, 0, returnbytes, i, LightData.Length);
  872. i += LightData.Length;
  873. }
  874. if (_sculptEntry)
  875. {
  876. byte[] SculptData = GetSculptBytes();
  877. returnbytes[i++] = (byte)(SculptEP % 256);
  878. returnbytes[i++] = (byte)((SculptEP >> 8) % 256);
  879. returnbytes[i++] = (byte)(SculptData.Length % 256);
  880. returnbytes[i++] = (byte)((SculptData.Length >> 8) % 256);
  881. returnbytes[i++] = (byte)((SculptData.Length >> 16) % 256);
  882. returnbytes[i++] = (byte)((SculptData.Length >> 24) % 256);
  883. Array.Copy(SculptData, 0, returnbytes, i, SculptData.Length);
  884. i += SculptData.Length;
  885. }
  886. if (_projectionEntry)
  887. {
  888. byte[] ProjectionData = GetProjectionBytes();
  889. returnbytes[i++] = (byte)(ProjectionEP % 256);
  890. returnbytes[i++] = (byte)((ProjectionEP >> 8) % 256);
  891. returnbytes[i++] = (byte)((ProjectionData.Length) % 256);
  892. returnbytes[i++] = (byte)((ProjectionData.Length >> 16) % 256);
  893. returnbytes[i++] = (byte)((ProjectionData.Length >> 20) % 256);
  894. returnbytes[i++] = (byte)((ProjectionData.Length >> 24) % 256);
  895. Array.Copy(ProjectionData, 0, returnbytes, i, ProjectionData.Length);
  896. i += ProjectionData.Length;
  897. }
  898. if (!_flexiEntry && !_lightEntry && !_sculptEntry && !_projectionEntry)
  899. {
  900. byte[] returnbyte = new byte[1];
  901. returnbyte[0] = 0;
  902. return returnbyte;
  903. }
  904. return returnbytes;
  905. }
  906. public void ReadInUpdateExtraParam(ushort type, bool inUse, byte[] data)
  907. {
  908. const ushort FlexiEP = 0x10;
  909. const ushort LightEP = 0x20;
  910. const ushort SculptEP = 0x30;
  911. const ushort ProjectionEP = 0x40;
  912. switch (type)
  913. {
  914. case FlexiEP:
  915. if (!inUse)
  916. {
  917. _flexiEntry = false;
  918. return;
  919. }
  920. ReadFlexiData(data, 0);
  921. break;
  922. case LightEP:
  923. if (!inUse)
  924. {
  925. _lightEntry = false;
  926. return;
  927. }
  928. ReadLightData(data, 0);
  929. break;
  930. case SculptEP:
  931. if (!inUse)
  932. {
  933. _sculptEntry = false;
  934. return;
  935. }
  936. ReadSculptData(data, 0);
  937. break;
  938. case ProjectionEP:
  939. if (!inUse)
  940. {
  941. _projectionEntry = false;
  942. return;
  943. }
  944. ReadProjectionData(data, 0);
  945. break;
  946. }
  947. }
  948. public void ReadInExtraParamsBytes(byte[] data)
  949. {
  950. if (data == null || data.Length == 1)
  951. return;
  952. const ushort FlexiEP = 0x10;
  953. const ushort LightEP = 0x20;
  954. const ushort SculptEP = 0x30;
  955. const ushort ProjectionEP = 0x40;
  956. bool lGotFlexi = false;
  957. bool lGotLight = false;
  958. bool lGotSculpt = false;
  959. bool lGotFilter = false;
  960. int i = 0;
  961. byte extraParamCount = 0;
  962. if (data.Length > 0)
  963. {
  964. extraParamCount = data[i++];
  965. }
  966. for (int k = 0; k < extraParamCount; k++)
  967. {
  968. ushort epType = Utils.BytesToUInt16(data, i);
  969. i += 2;
  970. // uint paramLength = Helpers.BytesToUIntBig(data, i);
  971. i += 4;
  972. switch (epType)
  973. {
  974. case FlexiEP:
  975. ReadFlexiData(data, i);
  976. i += 16;
  977. lGotFlexi = true;
  978. break;
  979. case LightEP:
  980. ReadLightData(data, i);
  981. i += 16;
  982. lGotLight = true;
  983. break;
  984. case SculptEP:
  985. ReadSculptData(data, i);
  986. i += 17;
  987. lGotSculpt = true;
  988. break;
  989. case ProjectionEP:
  990. ReadProjectionData(data, i);
  991. i += 28;
  992. lGotFilter = true;
  993. break;
  994. }
  995. }
  996. if (!lGotFlexi)
  997. _flexiEntry = false;
  998. if (!lGotLight)
  999. _lightEntry = false;
  1000. if (!lGotSculpt)
  1001. _sculptEntry = false;
  1002. if (!lGotFilter)
  1003. _projectionEntry = false;
  1004. }
  1005. public void ReadSculptData(byte[] data, int pos)
  1006. {
  1007. UUID SculptUUID;
  1008. byte SculptTypel;
  1009. if (data.Length-pos >= 17)
  1010. {
  1011. _sculptEntry = true;
  1012. byte[] SculptTextureUUID = new byte[16];
  1013. SculptTypel = data[16 + pos];
  1014. Array.Copy(data, pos, SculptTextureUUID,0, 16);
  1015. SculptUUID = new UUID(SculptTextureUUID, 0);
  1016. }
  1017. else
  1018. {
  1019. _sculptEntry = false;
  1020. SculptUUID = UUID.Zero;
  1021. SculptTypel = 0x00;
  1022. }
  1023. if (_sculptEntry)
  1024. {
  1025. if (_sculptType != (byte)1 && _sculptType != (byte)2 && _sculptType != (byte)3 && _sculptType != (byte)4)
  1026. _sculptType = 4;
  1027. }
  1028. _sculptTexture = SculptUUID;
  1029. _sculptType = SculptTypel;
  1030. //m_log.Info("[SCULPT]:" + SculptUUID.ToString());
  1031. }
  1032. public byte[] GetSculptBytes()
  1033. {
  1034. byte[] data = new byte[17];
  1035. _sculptTexture.GetBytes().CopyTo(data, 0);
  1036. data[16] = (byte)_sculptType;
  1037. return data;
  1038. }
  1039. public void ReadFlexiData(byte[] data, int pos)
  1040. {
  1041. if (data.Length-pos >= 16)
  1042. {
  1043. _flexiEntry = true;
  1044. _flexiSoftness = ((data[pos] & 0x80) >> 6) | ((data[pos + 1] & 0x80) >> 7);
  1045. _flexiTension = (float)(data[pos++] & 0x7F) / 10.0f;
  1046. _flexiDrag = (float)(data[pos++] & 0x7F) / 10.0f;
  1047. _flexiGravity = (float)(data[pos++] / 10.0f) - 10.0f;
  1048. _flexiWind = (float)data[pos++] / 10.0f;
  1049. Vector3 lForce = new Vector3(data, pos);
  1050. _flexiForceX = lForce.X;
  1051. _flexiForceY = lForce.Y;
  1052. _flexiForceZ = lForce.Z;
  1053. }
  1054. else
  1055. {
  1056. _flexiEntry = false;
  1057. _flexiSoftness = 0;
  1058. _flexiTension = 0.0f;
  1059. _flexiDrag = 0.0f;
  1060. _flexiGravity = 0.0f;
  1061. _flexiWind = 0.0f;
  1062. _flexiForceX = 0f;
  1063. _flexiForceY = 0f;
  1064. _flexiForceZ = 0f;
  1065. }
  1066. }
  1067. public byte[] GetFlexiBytes()
  1068. {
  1069. byte[] data = new byte[16];
  1070. int i = 0;
  1071. // Softness is packed in the upper bits of tension and drag
  1072. data[i] = (byte)((_flexiSoftness & 2) << 6);
  1073. data[i + 1] = (byte)((_flexiSoftness & 1) << 7);
  1074. data[i++] |= (byte)((byte)(_flexiTension * 10.01f) & 0x7F);
  1075. data[i++] |= (byte)((byte)(_flexiDrag * 10.01f) & 0x7F);
  1076. data[i++] = (byte)((_flexiGravity + 10.0f) * 10.01f);
  1077. data[i++] = (byte)(_flexiWind * 10.01f);
  1078. Vector3 lForce = new Vector3(_flexiForceX, _flexiForceY, _flexiForceZ);
  1079. lForce.GetBytes().CopyTo(data, i);
  1080. return data;
  1081. }
  1082. public void ReadLightData(byte[] data, int pos)
  1083. {
  1084. if (data.Length - pos >= 16)
  1085. {
  1086. _lightEntry = true;
  1087. Color4 lColor = new Color4(data, pos, false);
  1088. _lightIntensity = lColor.A;
  1089. _lightColorA = 1f;
  1090. _lightColorR = lColor.R;
  1091. _lightColorG = lColor.G;
  1092. _lightColorB = lColor.B;
  1093. _lightRadius = Utils.BytesToFloat(data, pos + 4);
  1094. _lightCutoff = Utils.BytesToFloat(data, pos + 8);
  1095. _lightFalloff = Utils.BytesToFloat(data, pos + 12);
  1096. }
  1097. else
  1098. {
  1099. _lightEntry = false;
  1100. _lightColorA = 1f;
  1101. _lightColorR = 0f;
  1102. _lightColorG = 0f;
  1103. _lightColorB = 0f;
  1104. _lightRadius = 0f;
  1105. _lightCutoff = 0f;
  1106. _lightFalloff = 0f;
  1107. _lightIntensity = 0f;
  1108. }
  1109. }
  1110. public byte[] GetLightBytes()
  1111. {
  1112. byte[] data = new byte[16];
  1113. // Alpha channel in color is intensity
  1114. Color4 tmpColor = new Color4(_lightColorR,_lightColorG,_lightColorB,_lightIntensity);
  1115. tmpColor.GetBytes().CopyTo(data, 0);
  1116. Utils.FloatToBytes(_lightRadius).CopyTo(data, 4);
  1117. Utils.FloatToBytes(_lightCutoff).CopyTo(data, 8);
  1118. Utils.FloatToBytes(_lightFalloff).CopyTo(data, 12);
  1119. return data;
  1120. }
  1121. public void ReadProjectionData(byte[] data, int pos)
  1122. {
  1123. byte[] ProjectionTextureUUID = new byte[16];
  1124. if (data.Length - pos >= 28)
  1125. {
  1126. _projectionEntry = true;
  1127. Array.Copy(data, pos, ProjectionTextureUUID,0, 16);
  1128. _projectionTextureID = new UUID(ProjectionTextureUUID, 0);
  1129. _projectionFOV = Utils.BytesToFloat(data, pos + 16);
  1130. _projectionFocus = Utils.BytesToFloat(data, pos + 20);
  1131. _projectionAmb = Utils.BytesToFloat(data, pos + 24);
  1132. }
  1133. else
  1134. {
  1135. _projectionEntry = false;
  1136. _projectionTextureID = UUID.Zero;
  1137. _projectionFOV = 0f;
  1138. _projectionFocus = 0f;
  1139. _projectionAmb = 0f;
  1140. }
  1141. }
  1142. public byte[] GetProjectionBytes()
  1143. {
  1144. byte[] data = new byte[28];
  1145. _projectionTextureID.GetBytes().CopyTo(data, 0);
  1146. Utils.FloatToBytes(_projectionFOV).CopyTo(data, 16);
  1147. Utils.FloatToBytes(_projectionFocus).CopyTo(data, 20);
  1148. Utils.FloatToBytes(_projectionAmb).CopyTo(data, 24);
  1149. return data;
  1150. }
  1151. /// <summary>
  1152. /// Creates a OpenMetaverse.Primitive and populates it with converted PrimitiveBaseShape values
  1153. /// </summary>
  1154. /// <returns></returns>
  1155. public Primitive ToOmvPrimitive()
  1156. {
  1157. // position and rotation defaults here since they are not available in PrimitiveBaseShape
  1158. return ToOmvPrimitive(new Vector3(0.0f, 0.0f, 0.0f),
  1159. new Quaternion(0.0f, 0.0f, 0.0f, 1.0f));
  1160. }
  1161. /// <summary>
  1162. /// Creates a OpenMetaverse.Primitive and populates it with converted PrimitiveBaseShape values
  1163. /// </summary>
  1164. /// <param name="position"></param>
  1165. /// <param name="rotation"></param>
  1166. /// <returns></returns>
  1167. public Primitive ToOmvPrimitive(Vector3 position, Quaternion rotation)
  1168. {
  1169. OpenMetaverse.Primitive prim = new OpenMetaverse.Primitive();
  1170. prim.Scale = this.Scale;
  1171. prim.Position = position;
  1172. prim.Rotation = rotation;
  1173. if (this.SculptEntry)
  1174. {
  1175. prim.Sculpt = new Primitive.SculptData();
  1176. prim.Sculpt.Type = (OpenMetaverse.SculptType)this.SculptType;
  1177. prim.Sculpt.SculptTexture = this.SculptTexture;
  1178. }
  1179. prim.PrimData.PathShearX = this.PathShearX < 128 ? (float)this.PathShearX * 0.01f : (float)(this.PathShearX - 256) * 0.01f;
  1180. prim.PrimData.PathShearY = this.PathShearY < 128 ? (float)this.PathShearY * 0.01f : (float)(this.PathShearY - 256) * 0.01f;
  1181. prim.PrimData.PathBegin = (float)this.PathBegin * 2.0e-5f;
  1182. prim.PrimData.PathEnd = 1.0f - (float)this.PathEnd * 2.0e-5f;
  1183. prim.PrimData.PathScaleX = (200 - this.PathScaleX) * 0.01f;
  1184. prim.PrimData.PathScaleY = (200 - this.PathScaleY) * 0.01f;
  1185. prim.PrimData.PathTaperX = this.PathTaperX * 0.01f;
  1186. prim.PrimData.PathTaperY = this.PathTaperY * 0.01f;
  1187. prim.PrimData.PathTwistBegin = this.PathTwistBegin * 0.01f;
  1188. prim.PrimData.PathTwist = this.PathTwist * 0.01f;
  1189. prim.PrimData.ProfileBegin = (float)this.ProfileBegin * 2.0e-5f;
  1190. prim.PrimData.ProfileEnd = 1.0f - (float)this.ProfileEnd * 2.0e-5f;
  1191. prim.PrimData.ProfileHollow = (float)this.ProfileHollow * 2.0e-5f;
  1192. prim.PrimData.profileCurve = this.ProfileCurve;
  1193. prim.PrimData.ProfileHole = (HoleType)this.HollowShape;
  1194. prim.PrimData.PathCurve = (PathCurve)this.PathCurve;
  1195. prim.PrimData.PathRadiusOffset = 0.01f * this.PathRadiusOffset;
  1196. prim.PrimData.PathRevolutions = 1.0f + 0.015f * this.PathRevolutions;
  1197. prim.PrimData.PathSkew = 0.01f * this.PathSkew;
  1198. prim.PrimData.PCode = OpenMetaverse.PCode.Prim;
  1199. prim.PrimData.State = 0;
  1200. if (this.FlexiEntry)
  1201. {
  1202. prim.Flexible = new Primitive.FlexibleData();
  1203. prim.Flexible.Drag = this.FlexiDrag;
  1204. prim.Flexible.Force = new Vector3(this.FlexiForceX, this.FlexiForceY, this.FlexiForceZ);
  1205. prim.Flexible.Gravity = this.FlexiGravity;
  1206. prim.Flexible.Softness = this.FlexiSoftness;
  1207. prim.Flexible.Tension = this.FlexiTension;
  1208. prim.Flexible.Wind = this.FlexiWind;
  1209. }
  1210. if (this.LightEntry)
  1211. {
  1212. prim.Light = new Primitive.LightData();
  1213. prim.Light.Color = new Color4(this.LightColorR, this.LightColorG, this.LightColorB, this.LightColorA);
  1214. prim.Light.Cutoff = this.LightCutoff;
  1215. prim.Light.Falloff = this.LightFalloff;
  1216. prim.Light.Intensity = this.LightIntensity;
  1217. prim.Light.Radius = this.LightRadius;
  1218. }
  1219. prim.Textures = this.Textures;
  1220. prim.Properties = new Primitive.ObjectProperties();
  1221. prim.Properties.Name = "Primitive";
  1222. prim.Properties.Description = "";
  1223. prim.Properties.CreatorID = UUID.Zero;
  1224. prim.Properties.GroupID = UUID.Zero;
  1225. prim.Properties.OwnerID = UUID.Zero;
  1226. prim.Properties.Permissions = new Permissions();
  1227. prim.Properties.SalePrice = 10;
  1228. prim.Properties.SaleType = new SaleType();
  1229. return prim;
  1230. }
  1231. /// <summary>
  1232. /// Encapsulates a list of media entries.
  1233. /// </summary>
  1234. /// This class is necessary because we want to replace auto-serialization of MediaEntry with something more
  1235. /// OSD like and less vulnerable to change.
  1236. public class MediaList : List<MediaEntry>, IXmlSerializable
  1237. {
  1238. public const string MEDIA_TEXTURE_TYPE = "sl";
  1239. public MediaList() : base() {}
  1240. public MediaList(IEnumerable<MediaEntry> collection) : base(collection) {}
  1241. public MediaList(int capacity) : base(capacity) {}
  1242. public XmlSchema GetSchema()
  1243. {
  1244. return null;
  1245. }
  1246. public string ToXml()
  1247. {
  1248. lock (this)
  1249. {
  1250. using (StringWriter sw = new StringWriter())
  1251. {
  1252. using (XmlTextWriter xtw = new XmlTextWriter(sw))
  1253. {
  1254. xtw.WriteStartElement("OSMedia");
  1255. xtw.WriteAttributeString("type", MEDIA_TEXTURE_TYPE);
  1256. xtw.WriteAttributeString("version", "0.1");
  1257. OSDArray meArray = new OSDArray();
  1258. foreach (MediaEntry me in this)
  1259. {
  1260. OSD osd = (null == me ? new OSD() : me.GetOSD());
  1261. meArray.Add(osd);
  1262. }
  1263. xtw.WriteStartElement("OSData");
  1264. xtw.WriteRaw(OSDParser.SerializeLLSDXmlString(meArray));
  1265. xtw.WriteEndElement();
  1266. xtw.WriteEndElement();
  1267. xtw.Flush();
  1268. return sw.ToString();
  1269. }
  1270. }
  1271. }
  1272. }
  1273. public void WriteXml(XmlWriter writer)
  1274. {
  1275. writer.WriteRaw(ToXml());
  1276. }
  1277. public static MediaList FromXml(string rawXml)
  1278. {
  1279. MediaList ml = new MediaList();
  1280. ml.ReadXml(rawXml);
  1281. return ml;
  1282. }
  1283. public void ReadXml(string rawXml)
  1284. {
  1285. using (StringReader sr = new StringReader(rawXml))
  1286. {
  1287. using (XmlTextReader xtr = new XmlTextReader(sr))
  1288. {
  1289. xtr.MoveToContent();
  1290. string type = xtr.GetAttribute("type");
  1291. //m_log.DebugFormat("[MOAP]: Loaded media texture entry with type {0}", type);
  1292. if (type != MEDIA_TEXTURE_TYPE)
  1293. return;
  1294. xtr.ReadStartElement("OSMedia");
  1295. OSDArray osdMeArray = (OSDArray)OSDParser.DeserializeLLSDXml(xtr.ReadInnerXml());
  1296. foreach (OSD osdMe in osdMeArray)
  1297. {
  1298. MediaEntry me = (osdMe is OSDMap ? MediaEntry.FromOSD(osdMe) : new MediaEntry());
  1299. Add(me);
  1300. }
  1301. xtr.ReadEndElement();
  1302. }
  1303. }
  1304. }
  1305. public void ReadXml(XmlReader reader)
  1306. {
  1307. if (reader.IsEmptyElement)
  1308. return;
  1309. ReadXml(reader.ReadInnerXml());
  1310. }
  1311. }
  1312. }
  1313. }