source: 2014/24/EemeliK/Zombieland/Jypeli/Physics2DDotNet/DataTypes/MassInfo.cs @ 5974

Revision 5974, 7.9 KB checked in by empaheik, 4 years ago (diff)
Line 
1#region MIT License
2/*
3 * Copyright (c) 2005-2008 Jonathan Mark Porter. http://physics2d.googlepages.com/
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights to
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 * the Software, and to permit persons to whom the Software is furnished to do so,
10 * subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
17 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
19 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22#endregion
23
24
25
26
27#if UseDouble
28using Scalar = System.Double;
29#else
30using Scalar = System.Single;
31#endif
32using System;
33using AdvanceMath;
34using AdvanceMath.Design;
35
36using System.Runtime.Serialization;
37namespace Physics2DDotNet
38{
39
40    /// <summary>
41    /// This class Stores mass information and Moment of Inertia Together since they are very closly related.
42    /// </summary>
43#if !CompactFramework && !WindowsCE && !PocketPC && !XBOX360 && !SILVERLIGHT && !WINDOWS_PHONE
44    [Serializable]
45    [System.ComponentModel.TypeConverter(typeof(AdvTypeConverter<MassInfo>))]
46#endif
47    [AdvBrowsableOrder("Mass,MomentofInertia")]
48    public sealed class MassInfo : 
49#if !WINDOWS_PHONE
50        IDeserializationCallback, 
51#endif
52        IDuplicateable<MassInfo>
53    {
54        #region static
55        private static MassInfo infinite = new MassInfo(Scalar.PositiveInfinity, Scalar.PositiveInfinity);
56        /// <summary>
57        /// A body with this mass will not be affected by forces or impulse.
58        /// </summary>
59        /// <remarks>
60        /// This is the mass of Chuck Norris.
61        /// </remarks>
62        public static MassInfo Infinite
63        {
64            get { return new MassInfo(infinite); }
65        }
66
67        public static Scalar InertiaOfCylindricalShell(Scalar radius)
68        {
69            return radius * radius;
70        }
71        public static Scalar InertiaOfHollowCylinder(Scalar innerRadius, Scalar outerRadius)
72        {
73            return .5f * (innerRadius * innerRadius + outerRadius * outerRadius);
74        }
75        public static Scalar InertiaOfSolidCylinder(Scalar radius)
76        {
77            return .5f * (radius * radius);
78        }
79        public static Scalar InertiaOfRectangle(Scalar length, Scalar width)
80        {
81            return (1f / 12f) * (length * length + width * width);
82        }
83        public static Scalar InertiaOfSquare(Scalar sideLength)
84        {
85            return (1f / 6f) * (sideLength * sideLength);
86        }
87
88
89        public static MassInfo FromCylindricalShell(Scalar mass, Scalar radius)
90        {
91            return new MassInfo(mass, mass * radius * radius);
92        }
93        public static MassInfo FromHollowCylinder(Scalar mass, Scalar innerRadius, Scalar outerRadius)
94        {
95            return new MassInfo(mass, .5f * mass * (innerRadius * innerRadius + outerRadius * outerRadius));
96        }
97        public static MassInfo FromSolidCylinder(Scalar mass, Scalar radius)
98        {
99            return new MassInfo(mass, .5f * mass * (radius * radius));
100        }
101        public static MassInfo FromRectangle(Scalar mass, Scalar length, Scalar width)
102        {
103            return new MassInfo(mass, (1f / 12f) * mass * (length * length + width * width));
104        }
105        public static MassInfo FromSquare(Scalar mass, Scalar sideLength)
106        {
107            return new MassInfo(mass, (1f / 6f) * mass * (sideLength * sideLength));
108        }
109        public static MassInfo FromPolygon(Vector2D[] vertexes, Scalar mass)
110        {
111            if (vertexes == null) { throw new ArgumentNullException("vertexes"); }
112            if (vertexes.Length == 0) { throw new ArgumentOutOfRangeException("vertexes"); }
113
114            if (vertexes.Length == 1) { return new MassInfo(mass, 0); }
115
116            Scalar denom = 0.0f;
117            Scalar numer = 0.0f;
118
119            for (int j = vertexes.Length - 1, i = 0; i < vertexes.Length; j = i, i++)
120            {
121                Scalar a, b, c;
122                Vector2D P0 = vertexes[j];
123                Vector2D P1 = vertexes[i];
124                Vector2D.Dot(ref P1, ref P1, out a);
125                Vector2D.Dot(ref P1, ref P0, out b);
126                Vector2D.Dot(ref P0, ref P0, out c);
127                a += b + c;
128                Vector2D.ZCross(ref P0, ref P1, out b);
129                b = Math.Abs(b);
130                denom += (b * a);
131                numer += b;
132            }
133            return new MassInfo(mass, (mass * denom) / (numer * 6));
134        }
135
136        #endregion
137        #region fields
138        private Scalar mass;
139        private Scalar momentOfInertia;
140#if !WINDOWS_PHONE
141        [NonSerialized]
142#endif
143        private Scalar massInv;
144#if !WINDOWS_PHONE
145        [NonSerialized]
146#endif
147        private Scalar momentOfInertiaInv;
148#if !WINDOWS_PHONE
149        [NonSerialized]
150#endif
151        private Scalar accelerationDueToGravity;
152        #endregion
153        #region constructors
154        public MassInfo() { }
155        [InstanceConstructor("Mass,MomentofInertia")]
156        public MassInfo(Scalar mass, Scalar momentOfInertia)
157        {
158            this.MomentOfInertia = momentOfInertia;
159            this.Mass = mass;
160        }
161        private MassInfo(MassInfo copy)
162        {
163            this.mass = copy.mass;
164            this.momentOfInertia = copy.momentOfInertia;
165            this.massInv = copy.massInv;
166            this.momentOfInertiaInv = copy.momentOfInertiaInv;
167            this.accelerationDueToGravity = copy.accelerationDueToGravity;
168        }
169        #endregion
170        #region properties
171        [AdvBrowsable]
172        public Scalar Mass
173        {
174            get
175            {
176                return mass;
177            }
178            set
179            {
180                this.mass = value;
181                this.massInv = 1 / value;
182                this.accelerationDueToGravity = value * PhysicsHelper.GravitationalConstant;
183            }
184        }
185        [AdvBrowsable]
186        public Scalar MomentOfInertia
187        {
188            get
189            {
190                return momentOfInertia;
191            }
192            set
193            {
194                this.momentOfInertia = value;
195                this.momentOfInertiaInv = 1 / value;
196            }
197        }
198        public Scalar MassInv
199        {
200            get
201            {
202                return massInv;
203            }
204        }
205        public Scalar MomentOfInertiaInv
206        {
207            get
208            {
209                return momentOfInertiaInv;
210            }
211        }
212        public Scalar AccelerationDueToGravity
213        {
214            get
215            {
216                return accelerationDueToGravity;
217            }
218        }
219        #endregion
220        #region Methods
221        public MassInfo Duplicate()
222        {
223            return new MassInfo(this);
224        }
225        public object Clone()
226        {
227            return Duplicate();
228        }
229#if !WINDOWS_PHONE
230        void IDeserializationCallback.OnDeserialization(object sender)
231        {
232            this.massInv = 1 / this.mass;
233            this.momentOfInertiaInv = 1 / this.momentOfInertia;
234            this.accelerationDueToGravity = this.mass * PhysicsHelper.GravitationalConstant;
235        }
236#endif
237        #endregion
238    }
239}
Note: See TracBrowser for help on using the repository browser.