From f3173735fad0e0712086e4058151adf4815373e4 Mon Sep 17 00:00:00 2001 From: Sean Dague Date: Wed, 16 Jul 2008 15:10:35 +0000 Subject: Revert "refactoring of PrimitiveBaseShape to properties" This reverts commit 60e13a9997da89d224fbe8a97ab42bfc6114a45f. --- OpenSim/Framework/PrimitiveBaseShape.cs | 681 +++++++++++++++++++++++++------- 1 file changed, 539 insertions(+), 142 deletions(-) (limited to 'OpenSim/Framework/PrimitiveBaseShape.cs') diff --git a/OpenSim/Framework/PrimitiveBaseShape.cs b/OpenSim/Framework/PrimitiveBaseShape.cs index 12ca688..2811615 100644 --- a/OpenSim/Framework/PrimitiveBaseShape.cs +++ b/OpenSim/Framework/PrimitiveBaseShape.cs @@ -78,23 +78,57 @@ namespace OpenSim.Framework private byte[] m_textureEntry; - public ushort PathBegin; - public byte PathCurve; - public ushort PathEnd; - public sbyte PathRadiusOffset; - public byte PathRevolutions; - public byte PathScaleX; - public byte PathScaleY; - public byte PathShearX; - public byte PathShearY; - public sbyte PathSkew; - public sbyte PathTaperX; - public sbyte PathTaperY; - public sbyte PathTwist; - public sbyte PathTwistBegin; - public byte PCode; - public ushort ProfileBegin; + public ushort _pathBegin; + public byte _pathCurve; + public ushort _pathEnd; + public sbyte _pathRadiusOffset; + public byte _pathRevolutions; + public byte _pathScaleX; + public byte _pathScaleY; + public byte _pathShearX; + public byte _pathShearY; + public sbyte _pathSkew; + public sbyte _pathTaperX; + public sbyte _pathTaperY; + public sbyte _pathTwist; + public sbyte _pathTwistBegin; + public byte _pCode; + public ushort _profileBegin; + public ushort _profileEnd; + public ushort _profileHollow; + public LLVector3 _scale; + public byte _state; + public ProfileShape _profileShape; + public HollowShape _hollowShape; + // Sculpted + [XmlIgnore] public LLUUID _sculptTexture = LLUUID.Zero; + [XmlIgnore] public byte _sculptType = (byte)0; + [XmlIgnore] public byte[] _sculptData = new byte[0]; + + // Flexi + [XmlIgnore] public int _flexiSoftness = 0; + [XmlIgnore] public float _flexiTension = 0f; + [XmlIgnore] public float _flexiDrag = 0f; + [XmlIgnore] public float _flexiGravity = 0f; + [XmlIgnore] public float _flexiWind = 0f; + [XmlIgnore] public float _flexiForceX = 0f; + [XmlIgnore] public float _flexiForceY = 0f; + [XmlIgnore] public float _flexiForceZ = 0f; + + //Bright n sparkly + [XmlIgnore] public float _lightColorR = 0f; + [XmlIgnore] public float _lightColorG = 0f; + [XmlIgnore] public float _lightColorB = 0f; + [XmlIgnore] public float _lightColorA = 1f; + [XmlIgnore] public float _lightRadius = 0f; + [XmlIgnore] public float _lightCutoff = 0f; + [XmlIgnore] public float _lightFalloff = 0f; + [XmlIgnore] public float _lightIntensity = 1f; + [XmlIgnore] public bool _flexiEntry = false; + [XmlIgnore] public bool _lightEntry = false; + [XmlIgnore] public bool _sculptEntry = false; + public byte ProfileCurve { get { return (byte)((byte)HollowShape | (byte)ProfileShape); } @@ -110,11 +144,11 @@ namespace OpenSim.Framework "[SHAPE]: Attempt to set a ProfileCurve with a hollow shape value of {0}, which isn't a valid enum. Replacing with default shape.", hollowShapeByte); - this.HollowShape = HollowShape.Same; + this._hollowShape = HollowShape.Same; } else { - this.HollowShape = (HollowShape)hollowShapeByte; + this._hollowShape = (HollowShape)hollowShapeByte; } // Handle profile shape component @@ -126,47 +160,16 @@ namespace OpenSim.Framework "[SHAPE]: Attempt to set a ProfileCurve with a profile shape value of {0}, which isn't a valid enum. Replacing with square.", profileShapeByte); - this.ProfileShape = ProfileShape.Square; + this._profileShape = ProfileShape.Square; } else { - this.ProfileShape = (ProfileShape)profileShapeByte; + this._profileShape = (ProfileShape)profileShapeByte; } } } - public ushort ProfileEnd; - public ushort ProfileHollow; - public LLVector3 Scale; - public byte State; - // Sculpted - [XmlIgnore] public LLUUID SculptTexture = LLUUID.Zero; - [XmlIgnore] public byte SculptType = (byte)0; - [XmlIgnore] public byte[] SculptData = new byte[0]; - - // Flexi - [XmlIgnore] public int FlexiSoftness = 0; - [XmlIgnore] public float FlexiTension = 0f; - [XmlIgnore] public float FlexiDrag = 0f; - [XmlIgnore] public float FlexiGravity = 0f; - [XmlIgnore] public float FlexiWind = 0f; - [XmlIgnore] public float FlexiForceX = 0f; - [XmlIgnore] public float FlexiForceY = 0f; - [XmlIgnore] public float FlexiForceZ = 0f; - - //Bright n sparkly - [XmlIgnore] public float LightColorR = 0f; - [XmlIgnore] public float LightColorG = 0f; - [XmlIgnore] public float LightColorB = 0f; - [XmlIgnore] public float LightColorA = 1f; - [XmlIgnore] public float LightRadius = 0f; - [XmlIgnore] public float LightCutoff = 0f; - [XmlIgnore] public float LightFalloff = 0f; - [XmlIgnore] public float LightIntensity = 1f; - [XmlIgnore] public bool FlexiEntry = false; - [XmlIgnore] public bool LightEntry = false; - [XmlIgnore] public bool SculptEntry = false; static PrimitiveBaseShape() @@ -197,9 +200,7 @@ namespace OpenSim.Framework set { m_textureEntry = value; } } - public ProfileShape ProfileShape; - public HollowShape HollowShape; public static PrimitiveBaseShape Default { @@ -223,10 +224,10 @@ namespace OpenSim.Framework { PrimitiveBaseShape shape = Create(); - shape.PathCurve = (byte) Extrusion.Straight; - shape.ProfileShape = ProfileShape.Square; - shape.PathScaleX = 100; - shape.PathScaleY = 100; + shape._pathCurve = (byte) Extrusion.Straight; + shape._profileShape = ProfileShape.Square; + shape._pathScaleX = 100; + shape._pathScaleY = 100; return shape; } @@ -235,28 +236,28 @@ namespace OpenSim.Framework { PrimitiveBaseShape shape = Create(); - shape.PathCurve = (byte) Extrusion.Curve1; - shape.ProfileShape = ProfileShape.Square; + shape._pathCurve = (byte) Extrusion.Curve1; + shape._profileShape = ProfileShape.Square; - shape.PathScaleX = 100; - shape.PathScaleY = 100; + shape._pathScaleX = 100; + shape._pathScaleY = 100; return shape; } public void SetScale(float side) { - Scale = new LLVector3(side, side, side); + _scale = new LLVector3(side, side, side); } public void SetHeigth(float heigth) { - Scale.Z = heigth; + _scale.Z = heigth; } public void SetRadius(float radius) { - Scale.X = Scale.Y = radius * 2f; + _scale.X = _scale.Y = radius * 2f; } // TODO: void returns need to change of course @@ -281,20 +282,20 @@ namespace OpenSim.Framework public void SetPathRange(LLVector3 pathRange) { - PathBegin = LLObject.PackBeginCut(pathRange.X); - PathEnd = LLObject.PackEndCut(pathRange.Y); + _pathBegin = LLObject.PackBeginCut(pathRange.X); + _pathEnd = LLObject.PackEndCut(pathRange.Y); } public void SetSculptData(byte sculptType, LLUUID SculptTextureUUID) { - SculptType = sculptType; - SculptTexture = SculptTextureUUID; + _sculptType = sculptType; + _sculptTexture = SculptTextureUUID; } public void SetProfileRange(LLVector3 profileRange) { - ProfileBegin = LLObject.PackBeginCut(profileRange.X); - ProfileEnd = LLObject.PackEndCut(profileRange.Y); + _profileBegin = LLObject.PackBeginCut(profileRange.X); + _profileEnd = LLObject.PackEndCut(profileRange.Y); } public byte[] ExtraParams @@ -309,6 +310,402 @@ namespace OpenSim.Framework } } + public ushort PathBegin { + get { + return _pathBegin; + } + set { + _pathBegin = value; + } + } + + public byte PathCurve { + get { + return _pathCurve; + } + set { + _pathCurve = value; + } + } + + public ushort PathEnd { + get { + return _pathEnd; + } + set { + _pathEnd = value; + } + } + + public sbyte PathRadiusOffset { + get { + return _pathRadiusOffset; + } + set { + _pathRadiusOffset = value; + } + } + + public byte PathRevolutions { + get { + return _pathRevolutions; + } + set { + _pathRevolutions = value; + } + } + + public byte PathScaleX { + get { + return _pathScaleX; + } + set { + _pathScaleX = value; + } + } + + public byte PathScaleY { + get { + return _pathScaleY; + } + set { + _pathScaleY = value; + } + } + + public byte PathShearX { + get { + return _pathShearX; + } + set { + _pathShearX = value; + } + } + + public byte PathShearY { + get { + return _pathShearY; + } + set { + _pathShearY = value; + } + } + + public sbyte PathSkew { + get { + return _pathSkew; + } + set { + _pathSkew = value; + } + } + + public sbyte PathTaperX { + get { + return _pathTaperX; + } + set { + _pathTaperX = value; + } + } + + public sbyte PathTaperY { + get { + return _pathTaperY; + } + set { + _pathTaperY = value; + } + } + + public sbyte PathTwist { + get { + return _pathTwist; + } + set { + _pathTwist = value; + } + } + + public sbyte PathTwistBegin { + get { + return _pathTwistBegin; + } + set { + _pathTwistBegin = value; + } + } + + public byte PCode { + get { + return _pCode; + } + set { + _pCode = value; + } + } + + public ushort ProfileBegin { + get { + return _profileBegin; + } + set { + _profileBegin = value; + } + } + + public ushort ProfileEnd { + get { + return _profileEnd; + } + set { + _profileEnd = value; + } + } + + public ushort ProfileHollow { + get { + return _profileHollow; + } + set { + _profileHollow = value; + } + } + + public LLVector3 Scale { + get { + return _scale; + } + set { + _scale = value; + } + } + + public byte State { + get { + return _state; + } + set { + _state = value; + } + } + + public ProfileShape ProfileShape { + get { + return _profileShape; + } + set { + _profileShape = value; + } + } + + public HollowShape HollowShape { + get { + return _hollowShape; + } + set { + _hollowShape = value; + } + } + + public LLUUID SculptTexture { + get { + return _sculptTexture; + } + set { + _sculptTexture = value; + } + } + + public byte SculptType { + get { + return _sculptType; + } + set { + _sculptType = value; + } + } + + public byte[] SculptData { + get { + return _sculptData; + } + set { + _sculptData = value; + } + } + + public int FlexiSoftness { + get { + return _flexiSoftness; + } + set { + _flexiSoftness = value; + } + } + + public float FlexiTension { + get { + return _flexiTension; + } + set { + _flexiTension = value; + } + } + + public float FlexiDrag { + get { + return _flexiDrag; + } + set { + _flexiDrag = value; + } + } + + public float FlexiGravity { + get { + return _flexiGravity; + } + set { + _flexiGravity = value; + } + } + + public float FlexiWind { + get { + return _flexiWind; + } + set { + _flexiWind = value; + } + } + + public float FlexiForceX { + get { + return _flexiForceX; + } + set { + _flexiForceX = value; + } + } + + public float FlexiForceY { + get { + return _flexiForceY; + } + set { + _flexiForceY = value; + } + } + + public float FlexiForceZ { + get { + return _flexiForceZ; + } + set { + _flexiForceZ = value; + } + } + + public float LightColorR { + get { + return _lightColorR; + } + set { + _lightColorR = value; + } + } + + public float LightColorG { + get { + return _lightColorG; + } + set { + _lightColorG = value; + } + } + + public float LightColorB { + get { + return _lightColorB; + } + set { + _lightColorB = value; + } + } + + public float LightColorA { + get { + return _lightColorA; + } + set { + _lightColorA = value; + } + } + + public float LightRadius { + get { + return _lightRadius; + } + set { + _lightRadius = value; + } + } + + public float LightCutoff { + get { + return _lightCutoff; + } + set { + _lightCutoff = value; + } + } + + public float LightFalloff { + get { + return _lightFalloff; + } + set { + _lightFalloff = value; + } + } + + public float LightIntensity { + get { + return _lightIntensity; + } + set { + _lightIntensity = value; + } + } + + public bool FlexiEntry { + get { + return _flexiEntry; + } + set { + _flexiEntry = value; + } + } + + public bool LightEntry { + get { + return _lightEntry; + } + set { + _lightEntry = value; + } + } + + public bool SculptEntry { + get { + return _sculptEntry; + } + set { + _sculptEntry = value; + } + } + public byte[] ExtraParamsToBytes() { ushort FlexiEP = 0x10; @@ -319,19 +716,19 @@ namespace OpenSim.Framework uint TotalBytesLength = 1; // ExtraParamsNum uint ExtraParamsNum = 0; - if (FlexiEntry) + if (_flexiEntry) { ExtraParamsNum++; TotalBytesLength += 16;// data TotalBytesLength += 2 + 4; // type } - if (LightEntry) + if (_lightEntry) { ExtraParamsNum++; TotalBytesLength += 16;// data TotalBytesLength += 2 + 4; // type } - if (SculptEntry) + if (_sculptEntry) { ExtraParamsNum++; TotalBytesLength += 17;// data @@ -346,7 +743,7 @@ namespace OpenSim.Framework // Stick in the number of parameters returnbytes[i++] = (byte)ExtraParamsNum; - if (FlexiEntry) + if (_flexiEntry) { byte[] FlexiData = GetFlexiBytes(); @@ -360,7 +757,7 @@ namespace OpenSim.Framework Array.Copy(FlexiData, 0, returnbytes, i, FlexiData.Length); i += FlexiData.Length; } - if (LightEntry) + if (_lightEntry) { byte[] LightData = GetLightBytes(); @@ -374,7 +771,7 @@ namespace OpenSim.Framework Array.Copy(LightData, 0, returnbytes, i, LightData.Length); i += LightData.Length; } - if (SculptEntry) + if (_sculptEntry) { byte[] SculptData = GetSculptBytes(); @@ -389,7 +786,7 @@ namespace OpenSim.Framework i += SculptData.Length; } - if (!FlexiEntry && !LightEntry && !SculptEntry) + if (!_flexiEntry && !_lightEntry && !_sculptEntry) { byte[] returnbyte = new byte[1]; returnbyte[0] = 0; @@ -413,7 +810,7 @@ namespace OpenSim.Framework case FlexiEP: if (!inUse) { - FlexiEntry = false; + _flexiEntry = false; return; } ReadFlexiData(data, 0); @@ -422,7 +819,7 @@ namespace OpenSim.Framework case LightEP: if (!inUse) { - LightEntry = false; + _lightEntry = false; return; } ReadLightData(data, 0); @@ -431,7 +828,7 @@ namespace OpenSim.Framework case SculptEP: if (!inUse) { - SculptEntry = false; + _sculptEntry = false; return; } ReadSculptData(data, 0); @@ -488,11 +885,11 @@ namespace OpenSim.Framework } if (!lGotFlexi) - FlexiEntry = false; + _flexiEntry = false; if (!lGotLight) - LightEntry = false; + _lightEntry = false; if (!lGotSculpt) - SculptEntry = false; + _sculptEntry = false; } @@ -504,7 +901,7 @@ namespace OpenSim.Framework if (data.Length+pos >= 17) { - SculptEntry = true; + _sculptEntry = true; SculptTextureUUID = new byte[16]; SculptTypel = data[16 + pos]; Array.Copy(data, pos, SculptTextureUUID,0, 16); @@ -512,18 +909,18 @@ namespace OpenSim.Framework } else { - SculptEntry = false; + _sculptEntry = false; SculptUUID = LLUUID.Zero; SculptTypel = 0x00; } - if (SculptEntry) + if (_sculptEntry) { - if (SculptType != (byte)1 && SculptType != (byte)2 && SculptType != (byte)3 && SculptType != (byte)4) - SculptType = 4; + if (_sculptType != (byte)1 && _sculptType != (byte)2 && _sculptType != (byte)3 && _sculptType != (byte)4) + _sculptType = 4; } - SculptTexture = SculptUUID; - SculptType = SculptTypel; + _sculptTexture = SculptUUID; + _sculptType = SculptTypel; //m_log.Info("[SCULPT]:" + SculptUUID.ToString()); } @@ -531,8 +928,8 @@ namespace OpenSim.Framework { byte[] data = new byte[17]; - SculptTexture.GetBytes().CopyTo(data, 0); - data[16] = (byte)SculptType; + _sculptTexture.GetBytes().CopyTo(data, 0); + data[16] = (byte)_sculptType; return data; } @@ -541,30 +938,30 @@ namespace OpenSim.Framework { if (data.Length-pos >= 16) { - FlexiEntry = true; - FlexiSoftness = ((data[pos] & 0x80) >> 6) | ((data[pos + 1] & 0x80) >> 7); + _flexiEntry = true; + _flexiSoftness = ((data[pos] & 0x80) >> 6) | ((data[pos + 1] & 0x80) >> 7); - FlexiTension = (float)(data[pos++] & 0x7F) / 10.0f; - FlexiDrag = (float)(data[pos++] & 0x7F) / 10.0f; - FlexiGravity = (float)(data[pos++] / 10.0f) - 10.0f; - FlexiWind = (float)data[pos++] / 10.0f; + _flexiTension = (float)(data[pos++] & 0x7F) / 10.0f; + _flexiDrag = (float)(data[pos++] & 0x7F) / 10.0f; + _flexiGravity = (float)(data[pos++] / 10.0f) - 10.0f; + _flexiWind = (float)data[pos++] / 10.0f; LLVector3 lForce = new LLVector3(data, pos); - FlexiForceX = lForce.X; - FlexiForceY = lForce.Y; - FlexiForceZ = lForce.Z; + _flexiForceX = lForce.X; + _flexiForceY = lForce.Y; + _flexiForceZ = lForce.Z; } else { - FlexiEntry = false; - FlexiSoftness = 0; - - FlexiTension = 0.0f; - FlexiDrag = 0.0f; - FlexiGravity = 0.0f; - FlexiWind = 0.0f; - FlexiForceX = 0f; - FlexiForceY = 0f; - FlexiForceZ = 0f; + _flexiEntry = false; + _flexiSoftness = 0; + + _flexiTension = 0.0f; + _flexiDrag = 0.0f; + _flexiGravity = 0.0f; + _flexiWind = 0.0f; + _flexiForceX = 0f; + _flexiForceY = 0f; + _flexiForceZ = 0f; } } @@ -574,14 +971,14 @@ namespace OpenSim.Framework int i = 0; // Softness is packed in the upper bits of tension and drag - data[i] = (byte)((FlexiSoftness & 2) << 6); - data[i + 1] = (byte)((FlexiSoftness & 1) << 7); - - data[i++] |= (byte)((byte)(FlexiTension * 10.01f) & 0x7F); - data[i++] |= (byte)((byte)(FlexiDrag * 10.01f) & 0x7F); - data[i++] = (byte)((FlexiGravity + 10.0f) * 10.01f); - data[i++] = (byte)(FlexiWind * 10.01f); - LLVector3 lForce = new LLVector3(FlexiForceX, FlexiForceY, FlexiForceZ); + data[i] = (byte)((_flexiSoftness & 2) << 6); + data[i + 1] = (byte)((_flexiSoftness & 1) << 7); + + data[i++] |= (byte)((byte)(_flexiTension * 10.01f) & 0x7F); + data[i++] |= (byte)((byte)(_flexiDrag * 10.01f) & 0x7F); + data[i++] = (byte)((_flexiGravity + 10.0f) * 10.01f); + data[i++] = (byte)(_flexiWind * 10.01f); + LLVector3 lForce = new LLVector3(_flexiForceX, _flexiForceY, _flexiForceZ); lForce.GetBytes().CopyTo(data, i); return data; @@ -591,29 +988,29 @@ namespace OpenSim.Framework { if (data.Length - pos >= 16) { - LightEntry = true; + _lightEntry = true; LLColor lColor = new LLColor(data, pos, false); - LightIntensity = lColor.A; - LightColorA = 1f; - LightColorR = lColor.R; - LightColorG = lColor.G; - LightColorB = lColor.B; - - LightRadius = Helpers.BytesToFloat(data, pos + 4); - LightCutoff = Helpers.BytesToFloat(data, pos + 8); - LightFalloff = Helpers.BytesToFloat(data, pos + 12); + _lightIntensity = lColor.A; + _lightColorA = 1f; + _lightColorR = lColor.R; + _lightColorG = lColor.G; + _lightColorB = lColor.B; + + _lightRadius = Helpers.BytesToFloat(data, pos + 4); + _lightCutoff = Helpers.BytesToFloat(data, pos + 8); + _lightFalloff = Helpers.BytesToFloat(data, pos + 12); } else { - LightEntry = false; - LightColorA = 1f; - LightColorR = 0f; - LightColorG = 0f; - LightColorB = 0f; - LightRadius = 0f; - LightCutoff = 0f; - LightFalloff = 0f; - LightIntensity = 0f; + _lightEntry = false; + _lightColorA = 1f; + _lightColorR = 0f; + _lightColorG = 0f; + _lightColorB = 0f; + _lightRadius = 0f; + _lightCutoff = 0f; + _lightFalloff = 0f; + _lightIntensity = 0f; } } @@ -622,12 +1019,12 @@ namespace OpenSim.Framework byte[] data = new byte[16]; // Alpha channel in color is intensity - LLColor tmpColor = new LLColor(LightColorR,LightColorG,LightColorB,LightIntensity); + LLColor tmpColor = new LLColor(_lightColorR,_lightColorG,_lightColorB,_lightIntensity); tmpColor.GetBytes().CopyTo(data, 0); - Helpers.FloatToBytes(LightRadius).CopyTo(data, 4); - Helpers.FloatToBytes(LightCutoff).CopyTo(data, 8); - Helpers.FloatToBytes(LightFalloff).CopyTo(data, 12); + Helpers.FloatToBytes(_lightRadius).CopyTo(data, 4); + Helpers.FloatToBytes(_lightCutoff).CopyTo(data, 8); + Helpers.FloatToBytes(_lightFalloff).CopyTo(data, 12); return data; } -- cgit v1.1