diff options
author | UbitUmarov | 2015-09-08 17:34:27 +0100 |
---|---|---|
committer | UbitUmarov | 2015-09-08 17:34:27 +0100 |
commit | e8d5f23fc46fab2e29f7d82cdfefc82879c2e6ea (patch) | |
tree | 0d8186fe5284789d4431f9eaaba3c91089103c9a /OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs | |
parent | opps my files? (diff) | |
download | opensim-SC_OLD-e8d5f23fc46fab2e29f7d82cdfefc82879c2e6ea.zip opensim-SC_OLD-e8d5f23fc46fab2e29f7d82cdfefc82879c2e6ea.tar.gz opensim-SC_OLD-e8d5f23fc46fab2e29f7d82cdfefc82879c2e6ea.tar.bz2 opensim-SC_OLD-e8d5f23fc46fab2e29f7d82cdfefc82879c2e6ea.tar.xz |
opps my files?
Diffstat (limited to 'OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs')
-rw-r--r-- | OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs new file mode 100644 index 0000000..284d9fe --- /dev/null +++ b/OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs | |||
@@ -0,0 +1,340 @@ | |||
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 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Diagnostics; | ||
31 | using System.Globalization; | ||
32 | using OpenMetaverse; | ||
33 | using OpenSim.Region.PhysicsModules.SharedBase; | ||
34 | using OpenSim.Region.PhysicsModules.UbitMeshing; | ||
35 | |||
36 | public class Vertex : IComparable<Vertex> | ||
37 | { | ||
38 | Vector3 vector; | ||
39 | |||
40 | public float X | ||
41 | { | ||
42 | get { return vector.X; } | ||
43 | set { vector.X = value; } | ||
44 | } | ||
45 | |||
46 | public float Y | ||
47 | { | ||
48 | get { return vector.Y; } | ||
49 | set { vector.Y = value; } | ||
50 | } | ||
51 | |||
52 | public float Z | ||
53 | { | ||
54 | get { return vector.Z; } | ||
55 | set { vector.Z = value; } | ||
56 | } | ||
57 | |||
58 | public Vertex(float x, float y, float z) | ||
59 | { | ||
60 | vector.X = x; | ||
61 | vector.Y = y; | ||
62 | vector.Z = z; | ||
63 | } | ||
64 | |||
65 | public Vertex normalize() | ||
66 | { | ||
67 | float tlength = vector.Length(); | ||
68 | if (tlength != 0f) | ||
69 | { | ||
70 | float mul = 1.0f / tlength; | ||
71 | return new Vertex(vector.X * mul, vector.Y * mul, vector.Z * mul); | ||
72 | } | ||
73 | else | ||
74 | { | ||
75 | return new Vertex(0f, 0f, 0f); | ||
76 | } | ||
77 | } | ||
78 | |||
79 | public Vertex cross(Vertex v) | ||
80 | { | ||
81 | return new Vertex(vector.Y * v.Z - vector.Z * v.Y, vector.Z * v.X - vector.X * v.Z, vector.X * v.Y - vector.Y * v.X); | ||
82 | } | ||
83 | |||
84 | // disable warning: mono compiler moans about overloading | ||
85 | // operators hiding base operator but should not according to C# | ||
86 | // language spec | ||
87 | #pragma warning disable 0108 | ||
88 | public static Vertex operator *(Vertex v, Quaternion q) | ||
89 | { | ||
90 | // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/ | ||
91 | |||
92 | Vertex v2 = new Vertex(0f, 0f, 0f); | ||
93 | |||
94 | v2.X = q.W * q.W * v.X + | ||
95 | 2f * q.Y * q.W * v.Z - | ||
96 | 2f * q.Z * q.W * v.Y + | ||
97 | q.X * q.X * v.X + | ||
98 | 2f * q.Y * q.X * v.Y + | ||
99 | 2f * q.Z * q.X * v.Z - | ||
100 | q.Z * q.Z * v.X - | ||
101 | q.Y * q.Y * v.X; | ||
102 | |||
103 | v2.Y = | ||
104 | 2f * q.X * q.Y * v.X + | ||
105 | q.Y * q.Y * v.Y + | ||
106 | 2f * q.Z * q.Y * v.Z + | ||
107 | 2f * q.W * q.Z * v.X - | ||
108 | q.Z * q.Z * v.Y + | ||
109 | q.W * q.W * v.Y - | ||
110 | 2f * q.X * q.W * v.Z - | ||
111 | q.X * q.X * v.Y; | ||
112 | |||
113 | v2.Z = | ||
114 | 2f * q.X * q.Z * v.X + | ||
115 | 2f * q.Y * q.Z * v.Y + | ||
116 | q.Z * q.Z * v.Z - | ||
117 | 2f * q.W * q.Y * v.X - | ||
118 | q.Y * q.Y * v.Z + | ||
119 | 2f * q.W * q.X * v.Y - | ||
120 | q.X * q.X * v.Z + | ||
121 | q.W * q.W * v.Z; | ||
122 | |||
123 | return v2; | ||
124 | } | ||
125 | |||
126 | public static Vertex operator +(Vertex v1, Vertex v2) | ||
127 | { | ||
128 | return new Vertex(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z); | ||
129 | } | ||
130 | |||
131 | public static Vertex operator -(Vertex v1, Vertex v2) | ||
132 | { | ||
133 | return new Vertex(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z); | ||
134 | } | ||
135 | |||
136 | public static Vertex operator *(Vertex v1, Vertex v2) | ||
137 | { | ||
138 | return new Vertex(v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z); | ||
139 | } | ||
140 | |||
141 | public static Vertex operator +(Vertex v1, float am) | ||
142 | { | ||
143 | v1.X += am; | ||
144 | v1.Y += am; | ||
145 | v1.Z += am; | ||
146 | return v1; | ||
147 | } | ||
148 | |||
149 | public static Vertex operator -(Vertex v1, float am) | ||
150 | { | ||
151 | v1.X -= am; | ||
152 | v1.Y -= am; | ||
153 | v1.Z -= am; | ||
154 | return v1; | ||
155 | } | ||
156 | |||
157 | public static Vertex operator *(Vertex v1, float am) | ||
158 | { | ||
159 | v1.X *= am; | ||
160 | v1.Y *= am; | ||
161 | v1.Z *= am; | ||
162 | return v1; | ||
163 | } | ||
164 | |||
165 | public static Vertex operator /(Vertex v1, float am) | ||
166 | { | ||
167 | if (am == 0f) | ||
168 | { | ||
169 | return new Vertex(0f,0f,0f); | ||
170 | } | ||
171 | float mul = 1.0f / am; | ||
172 | v1.X *= mul; | ||
173 | v1.Y *= mul; | ||
174 | v1.Z *= mul; | ||
175 | return v1; | ||
176 | } | ||
177 | #pragma warning restore 0108 | ||
178 | |||
179 | |||
180 | public float dot(Vertex v) | ||
181 | { | ||
182 | return X * v.X + Y * v.Y + Z * v.Z; | ||
183 | } | ||
184 | |||
185 | public Vertex(Vector3 v) | ||
186 | { | ||
187 | vector = v; | ||
188 | } | ||
189 | |||
190 | public Vertex Clone() | ||
191 | { | ||
192 | return new Vertex(X, Y, Z); | ||
193 | } | ||
194 | |||
195 | public static Vertex FromAngle(double angle) | ||
196 | { | ||
197 | return new Vertex((float) Math.Cos(angle), (float) Math.Sin(angle), 0.0f); | ||
198 | } | ||
199 | |||
200 | public float Length() | ||
201 | { | ||
202 | return vector.Length(); | ||
203 | } | ||
204 | |||
205 | public virtual bool Equals(Vertex v, float tolerance) | ||
206 | { | ||
207 | Vertex diff = this - v; | ||
208 | float d = diff.Length(); | ||
209 | if (d < tolerance) | ||
210 | return true; | ||
211 | |||
212 | return false; | ||
213 | } | ||
214 | |||
215 | |||
216 | public int CompareTo(Vertex other) | ||
217 | { | ||
218 | if (X < other.X) | ||
219 | return -1; | ||
220 | |||
221 | if (X > other.X) | ||
222 | return 1; | ||
223 | |||
224 | if (Y < other.Y) | ||
225 | return -1; | ||
226 | |||
227 | if (Y > other.Y) | ||
228 | return 1; | ||
229 | |||
230 | if (Z < other.Z) | ||
231 | return -1; | ||
232 | |||
233 | if (Z > other.Z) | ||
234 | return 1; | ||
235 | |||
236 | return 0; | ||
237 | } | ||
238 | |||
239 | public static bool operator >(Vertex me, Vertex other) | ||
240 | { | ||
241 | return me.CompareTo(other) > 0; | ||
242 | } | ||
243 | |||
244 | public static bool operator <(Vertex me, Vertex other) | ||
245 | { | ||
246 | return me.CompareTo(other) < 0; | ||
247 | } | ||
248 | |||
249 | public String ToRaw() | ||
250 | { | ||
251 | // Why this stuff with the number formatter? | ||
252 | // Well, the raw format uses the english/US notation of numbers | ||
253 | // where the "," separates groups of 1000 while the "." marks the border between 1 and 10E-1. | ||
254 | // The german notation uses these characters exactly vice versa! | ||
255 | // The Float.ToString() routine is a localized one, giving different results depending on the country | ||
256 | // settings your machine works with. Unusable for a machine readable file format :-( | ||
257 | NumberFormatInfo nfi = new NumberFormatInfo(); | ||
258 | nfi.NumberDecimalSeparator = "."; | ||
259 | nfi.NumberDecimalDigits = 6; | ||
260 | |||
261 | String s1 = X.ToString(nfi) + " " + Y.ToString(nfi) + " " + Z.ToString(nfi); | ||
262 | |||
263 | return s1; | ||
264 | } | ||
265 | } | ||
266 | |||
267 | public class Triangle | ||
268 | { | ||
269 | public Vertex v1; | ||
270 | public Vertex v2; | ||
271 | public Vertex v3; | ||
272 | |||
273 | public Triangle(Vertex _v1, Vertex _v2, Vertex _v3) | ||
274 | { | ||
275 | v1 = _v1; | ||
276 | v2 = _v2; | ||
277 | v3 = _v3; | ||
278 | } | ||
279 | |||
280 | public Triangle(float _v1x,float _v1y,float _v1z, | ||
281 | float _v2x,float _v2y,float _v2z, | ||
282 | float _v3x,float _v3y,float _v3z) | ||
283 | { | ||
284 | v1 = new Vertex(_v1x, _v1y, _v1z); | ||
285 | v2 = new Vertex(_v2x, _v2y, _v2z); | ||
286 | v3 = new Vertex(_v3x, _v3y, _v3z); | ||
287 | } | ||
288 | |||
289 | public override String ToString() | ||
290 | { | ||
291 | NumberFormatInfo nfi = new NumberFormatInfo(); | ||
292 | nfi.CurrencyDecimalDigits = 2; | ||
293 | nfi.CurrencyDecimalSeparator = "."; | ||
294 | |||
295 | String s1 = "<" + v1.X.ToString(nfi) + "," + v1.Y.ToString(nfi) + "," + v1.Z.ToString(nfi) + ">"; | ||
296 | String s2 = "<" + v2.X.ToString(nfi) + "," + v2.Y.ToString(nfi) + "," + v2.Z.ToString(nfi) + ">"; | ||
297 | String s3 = "<" + v3.X.ToString(nfi) + "," + v3.Y.ToString(nfi) + "," + v3.Z.ToString(nfi) + ">"; | ||
298 | |||
299 | return s1 + ";" + s2 + ";" + s3; | ||
300 | } | ||
301 | |||
302 | public Vector3 getNormal() | ||
303 | { | ||
304 | // Vertices | ||
305 | |||
306 | // Vectors for edges | ||
307 | Vector3 e1; | ||
308 | Vector3 e2; | ||
309 | |||
310 | e1 = new Vector3(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z); | ||
311 | e2 = new Vector3(v1.X - v3.X, v1.Y - v3.Y, v1.Z - v3.Z); | ||
312 | |||
313 | // Cross product for normal | ||
314 | Vector3 n = Vector3.Cross(e1, e2); | ||
315 | |||
316 | // Length | ||
317 | float l = n.Length(); | ||
318 | |||
319 | // Normalized "normal" | ||
320 | n = n/l; | ||
321 | |||
322 | return n; | ||
323 | } | ||
324 | |||
325 | public void invertNormal() | ||
326 | { | ||
327 | Vertex vt; | ||
328 | vt = v1; | ||
329 | v1 = v2; | ||
330 | v2 = vt; | ||
331 | } | ||
332 | |||
333 | // Dumps a triangle in the "raw faces" format, blender can import. This is for visualisation and | ||
334 | // debugging purposes | ||
335 | public String ToStringRaw() | ||
336 | { | ||
337 | String output = v1.ToRaw() + " " + v2.ToRaw() + " " + v3.ToRaw(); | ||
338 | return output; | ||
339 | } | ||
340 | } | ||