diff options
author | UbitUmarov | 2012-03-17 09:27:56 +0000 |
---|---|---|
committer | UbitUmarov | 2012-03-17 09:27:56 +0000 |
commit | 41a0c850f887d72ff64e9e616ea4bda25fd85de7 (patch) | |
tree | c0c22d6c5e75c3dfa7147baa56f82bf5d7c496b3 | |
parent | some more work on costs (diff) | |
download | opensim-SC-41a0c850f887d72ff64e9e616ea4bda25fd85de7.zip opensim-SC-41a0c850f887d72ff64e9e616ea4bda25fd85de7.tar.gz opensim-SC-41a0c850f887d72ff64e9e616ea4bda25fd85de7.tar.bz2 opensim-SC-41a0c850f887d72ff64e9e616ea4bda25fd85de7.tar.xz |
added a new UbitMeshing module so i can mess it...
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Region/Physics/UbitMeshing/HelperTypes.cs | 436 | ||||
-rw-r--r-- | OpenSim/Region/Physics/UbitMeshing/Mesh.cs | 401 | ||||
-rw-r--r-- | OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs | 762 | ||||
-rw-r--r-- | OpenSim/Region/Physics/UbitMeshing/PrimMesher.cs | 2284 | ||||
-rw-r--r-- | OpenSim/Region/Physics/UbitMeshing/SculptMap.cs | 197 | ||||
-rw-r--r-- | OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs | 646 | ||||
-rw-r--r-- | prebuild.xml | 31 |
7 files changed, 4757 insertions, 0 deletions
diff --git a/OpenSim/Region/Physics/UbitMeshing/HelperTypes.cs b/OpenSim/Region/Physics/UbitMeshing/HelperTypes.cs new file mode 100644 index 0000000..8cd8dcf --- /dev/null +++ b/OpenSim/Region/Physics/UbitMeshing/HelperTypes.cs | |||
@@ -0,0 +1,436 @@ | |||
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.Physics.Manager; | ||
34 | using OpenSim.Region.Physics.Meshing; | ||
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 = 3; | ||
260 | |||
261 | String s1 = X.ToString("N2", nfi) + " " + Y.ToString("N2", nfi) + " " + Z.ToString("N2", 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 | private float radius_square; | ||
274 | private float cx; | ||
275 | private float cy; | ||
276 | |||
277 | public Triangle(Vertex _v1, Vertex _v2, Vertex _v3) | ||
278 | { | ||
279 | v1 = _v1; | ||
280 | v2 = _v2; | ||
281 | v3 = _v3; | ||
282 | |||
283 | CalcCircle(); | ||
284 | } | ||
285 | |||
286 | public bool isInCircle(float x, float y) | ||
287 | { | ||
288 | float dx, dy; | ||
289 | float dd; | ||
290 | |||
291 | dx = x - cx; | ||
292 | dy = y - cy; | ||
293 | |||
294 | dd = dx*dx + dy*dy; | ||
295 | if (dd < radius_square) | ||
296 | return true; | ||
297 | else | ||
298 | return false; | ||
299 | } | ||
300 | |||
301 | public bool isDegraded() | ||
302 | { | ||
303 | // This means, the vertices of this triangle are somewhat strange. | ||
304 | // They either line up or at least two of them are identical | ||
305 | return (radius_square == 0.0); | ||
306 | } | ||
307 | |||
308 | private void CalcCircle() | ||
309 | { | ||
310 | // Calculate the center and the radius of a circle given by three points p1, p2, p3 | ||
311 | // It is assumed, that the triangles vertices are already set correctly | ||
312 | double p1x, p2x, p1y, p2y, p3x, p3y; | ||
313 | |||
314 | // Deviation of this routine: | ||
315 | // A circle has the general equation (M-p)^2=r^2, where M and p are vectors | ||
316 | // this gives us three equations f(p)=r^2, each for one point p1, p2, p3 | ||
317 | // putting respectively two equations together gives two equations | ||
318 | // f(p1)=f(p2) and f(p1)=f(p3) | ||
319 | // bringing all constant terms to one side brings them to the form | ||
320 | // M*v1=c1 resp.M*v2=c2 where v1=(p1-p2) and v2=(p1-p3) (still vectors) | ||
321 | // and c1, c2 are scalars (Naming conventions like the variables below) | ||
322 | // Now using the equations that are formed by the components of the vectors | ||
323 | // and isolate Mx lets you make one equation that only holds My | ||
324 | // The rest is straight forward and eaasy :-) | ||
325 | // | ||
326 | |||
327 | /* helping variables for temporary results */ | ||
328 | double c1, c2; | ||
329 | double v1x, v1y, v2x, v2y; | ||
330 | |||
331 | double z, n; | ||
332 | |||
333 | double rx, ry; | ||
334 | |||
335 | // Readout the three points, the triangle consists of | ||
336 | p1x = v1.X; | ||
337 | p1y = v1.Y; | ||
338 | |||
339 | p2x = v2.X; | ||
340 | p2y = v2.Y; | ||
341 | |||
342 | p3x = v3.X; | ||
343 | p3y = v3.Y; | ||
344 | |||
345 | /* calc helping values first */ | ||
346 | c1 = (p1x*p1x + p1y*p1y - p2x*p2x - p2y*p2y)/2; | ||
347 | c2 = (p1x*p1x + p1y*p1y - p3x*p3x - p3y*p3y)/2; | ||
348 | |||
349 | v1x = p1x - p2x; | ||
350 | v1y = p1y - p2y; | ||
351 | |||
352 | v2x = p1x - p3x; | ||
353 | v2y = p1y - p3y; | ||
354 | |||
355 | z = (c1*v2x - c2*v1x); | ||
356 | n = (v1y*v2x - v2y*v1x); | ||
357 | |||
358 | if (n == 0.0) // This is no triangle, i.e there are (at least) two points at the same location | ||
359 | { | ||
360 | radius_square = 0.0f; | ||
361 | return; | ||
362 | } | ||
363 | |||
364 | cy = (float) (z/n); | ||
365 | |||
366 | if (v2x != 0.0) | ||
367 | { | ||
368 | cx = (float) ((c2 - v2y*cy)/v2x); | ||
369 | } | ||
370 | else if (v1x != 0.0) | ||
371 | { | ||
372 | cx = (float) ((c1 - v1y*cy)/v1x); | ||
373 | } | ||
374 | else | ||
375 | { | ||
376 | Debug.Assert(false, "Malformed triangle"); /* Both terms zero means nothing good */ | ||
377 | } | ||
378 | |||
379 | rx = (p1x - cx); | ||
380 | ry = (p1y - cy); | ||
381 | |||
382 | radius_square = (float) (rx*rx + ry*ry); | ||
383 | } | ||
384 | |||
385 | public override String ToString() | ||
386 | { | ||
387 | NumberFormatInfo nfi = new NumberFormatInfo(); | ||
388 | nfi.CurrencyDecimalDigits = 2; | ||
389 | nfi.CurrencyDecimalSeparator = "."; | ||
390 | |||
391 | String s1 = "<" + v1.X.ToString(nfi) + "," + v1.Y.ToString(nfi) + "," + v1.Z.ToString(nfi) + ">"; | ||
392 | String s2 = "<" + v2.X.ToString(nfi) + "," + v2.Y.ToString(nfi) + "," + v2.Z.ToString(nfi) + ">"; | ||
393 | String s3 = "<" + v3.X.ToString(nfi) + "," + v3.Y.ToString(nfi) + "," + v3.Z.ToString(nfi) + ">"; | ||
394 | |||
395 | return s1 + ";" + s2 + ";" + s3; | ||
396 | } | ||
397 | |||
398 | public Vector3 getNormal() | ||
399 | { | ||
400 | // Vertices | ||
401 | |||
402 | // Vectors for edges | ||
403 | Vector3 e1; | ||
404 | Vector3 e2; | ||
405 | |||
406 | e1 = new Vector3(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z); | ||
407 | e2 = new Vector3(v1.X - v3.X, v1.Y - v3.Y, v1.Z - v3.Z); | ||
408 | |||
409 | // Cross product for normal | ||
410 | Vector3 n = Vector3.Cross(e1, e2); | ||
411 | |||
412 | // Length | ||
413 | float l = n.Length(); | ||
414 | |||
415 | // Normalized "normal" | ||
416 | n = n/l; | ||
417 | |||
418 | return n; | ||
419 | } | ||
420 | |||
421 | public void invertNormal() | ||
422 | { | ||
423 | Vertex vt; | ||
424 | vt = v1; | ||
425 | v1 = v2; | ||
426 | v2 = vt; | ||
427 | } | ||
428 | |||
429 | // Dumps a triangle in the "raw faces" format, blender can import. This is for visualisation and | ||
430 | // debugging purposes | ||
431 | public String ToStringRaw() | ||
432 | { | ||
433 | String output = v1.ToRaw() + " " + v2.ToRaw() + " " + v3.ToRaw(); | ||
434 | return output; | ||
435 | } | ||
436 | } | ||
diff --git a/OpenSim/Region/Physics/UbitMeshing/Mesh.cs b/OpenSim/Region/Physics/UbitMeshing/Mesh.cs new file mode 100644 index 0000000..c715642 --- /dev/null +++ b/OpenSim/Region/Physics/UbitMeshing/Mesh.cs | |||
@@ -0,0 +1,401 @@ | |||
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.IO; | ||
31 | using System.Runtime.InteropServices; | ||
32 | using OpenSim.Region.Physics.Manager; | ||
33 | using PrimMesher; | ||
34 | using OpenMetaverse; | ||
35 | |||
36 | namespace OpenSim.Region.Physics.Meshing | ||
37 | { | ||
38 | public class Mesh : IMesh | ||
39 | { | ||
40 | private Dictionary<Vertex, int> m_vertices; | ||
41 | private List<Triangle> m_triangles; | ||
42 | GCHandle m_pinnedVertexes; | ||
43 | GCHandle m_pinnedIndex; | ||
44 | IntPtr m_verticesPtr = IntPtr.Zero; | ||
45 | int m_vertexCount = 0; | ||
46 | IntPtr m_indicesPtr = IntPtr.Zero; | ||
47 | int m_indexCount = 0; | ||
48 | public float[] m_normals; | ||
49 | Vector3 _centroid; | ||
50 | int _centroidDiv; | ||
51 | |||
52 | private class vertexcomp : IEqualityComparer<Vertex> | ||
53 | { | ||
54 | public bool Equals(Vertex v1, Vertex v2) | ||
55 | { | ||
56 | if (v1.X == v2.X && v1.Y == v2.Y && v1.Z == v2.Z) | ||
57 | return true; | ||
58 | else | ||
59 | return false; | ||
60 | } | ||
61 | public int GetHashCode(Vertex v) | ||
62 | { | ||
63 | int a = v.X.GetHashCode(); | ||
64 | int b = v.Y.GetHashCode(); | ||
65 | int c = v.Z.GetHashCode(); | ||
66 | return (a << 16) ^ (b << 8) ^ c; | ||
67 | } | ||
68 | |||
69 | } | ||
70 | |||
71 | public Mesh() | ||
72 | { | ||
73 | vertexcomp vcomp = new vertexcomp(); | ||
74 | |||
75 | m_vertices = new Dictionary<Vertex, int>(vcomp); | ||
76 | m_triangles = new List<Triangle>(); | ||
77 | _centroid = Vector3.Zero; | ||
78 | _centroidDiv = 0; | ||
79 | } | ||
80 | |||
81 | public Mesh Clone() | ||
82 | { | ||
83 | Mesh result = new Mesh(); | ||
84 | |||
85 | foreach (Triangle t in m_triangles) | ||
86 | { | ||
87 | result.Add(new Triangle(t.v1.Clone(), t.v2.Clone(), t.v3.Clone())); | ||
88 | } | ||
89 | result._centroid = _centroid; | ||
90 | result._centroidDiv = _centroidDiv; | ||
91 | return result; | ||
92 | } | ||
93 | |||
94 | public void Add(Triangle triangle) | ||
95 | { | ||
96 | if (m_pinnedIndex.IsAllocated || m_pinnedVertexes.IsAllocated || m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero) | ||
97 | throw new NotSupportedException("Attempt to Add to a pinned Mesh"); | ||
98 | // If a vertex of the triangle is not yet in the vertices list, | ||
99 | // add it and set its index to the current index count | ||
100 | // vertex == seems broken | ||
101 | // skip colapsed triangles | ||
102 | if ((triangle.v1.X == triangle.v2.X && triangle.v1.Y == triangle.v2.Y && triangle.v1.Z == triangle.v2.Z) | ||
103 | || (triangle.v1.X == triangle.v3.X && triangle.v1.Y == triangle.v3.Y && triangle.v1.Z == triangle.v3.Z) | ||
104 | || (triangle.v2.X == triangle.v3.X && triangle.v2.Y == triangle.v3.Y && triangle.v2.Z == triangle.v3.Z) | ||
105 | ) | ||
106 | { | ||
107 | return; | ||
108 | } | ||
109 | |||
110 | if (m_vertices.Count == 0) | ||
111 | { | ||
112 | _centroidDiv = 0; | ||
113 | _centroid = Vector3.Zero; | ||
114 | } | ||
115 | |||
116 | if (!m_vertices.ContainsKey(triangle.v1)) | ||
117 | { | ||
118 | m_vertices[triangle.v1] = m_vertices.Count; | ||
119 | _centroid.X += triangle.v1.X; | ||
120 | _centroid.Y += triangle.v1.Y; | ||
121 | _centroid.Z += triangle.v1.Z; | ||
122 | _centroidDiv++; | ||
123 | } | ||
124 | if (!m_vertices.ContainsKey(triangle.v2)) | ||
125 | { | ||
126 | m_vertices[triangle.v2] = m_vertices.Count; | ||
127 | _centroid.X += triangle.v2.X; | ||
128 | _centroid.Y += triangle.v2.Y; | ||
129 | _centroid.Z += triangle.v2.Z; | ||
130 | _centroidDiv++; | ||
131 | } | ||
132 | if (!m_vertices.ContainsKey(triangle.v3)) | ||
133 | { | ||
134 | m_vertices[triangle.v3] = m_vertices.Count; | ||
135 | _centroid.X += triangle.v3.X; | ||
136 | _centroid.Y += triangle.v3.Y; | ||
137 | _centroid.Z += triangle.v3.Z; | ||
138 | _centroidDiv++; | ||
139 | } | ||
140 | m_triangles.Add(triangle); | ||
141 | } | ||
142 | |||
143 | public Vector3 GetCentroid() | ||
144 | { | ||
145 | if (_centroidDiv > 0) | ||
146 | return new Vector3(_centroid.X / _centroidDiv, _centroid.Y / _centroidDiv, _centroid.Z / _centroidDiv); | ||
147 | else | ||
148 | return Vector3.Zero; | ||
149 | } | ||
150 | |||
151 | public void CalcNormals() | ||
152 | { | ||
153 | int iTriangles = m_triangles.Count; | ||
154 | |||
155 | this.m_normals = new float[iTriangles * 3]; | ||
156 | |||
157 | int i = 0; | ||
158 | foreach (Triangle t in m_triangles) | ||
159 | { | ||
160 | float ux, uy, uz; | ||
161 | float vx, vy, vz; | ||
162 | float wx, wy, wz; | ||
163 | |||
164 | ux = t.v1.X; | ||
165 | uy = t.v1.Y; | ||
166 | uz = t.v1.Z; | ||
167 | |||
168 | vx = t.v2.X; | ||
169 | vy = t.v2.Y; | ||
170 | vz = t.v2.Z; | ||
171 | |||
172 | wx = t.v3.X; | ||
173 | wy = t.v3.Y; | ||
174 | wz = t.v3.Z; | ||
175 | |||
176 | |||
177 | // Vectors for edges | ||
178 | float e1x, e1y, e1z; | ||
179 | float e2x, e2y, e2z; | ||
180 | |||
181 | e1x = ux - vx; | ||
182 | e1y = uy - vy; | ||
183 | e1z = uz - vz; | ||
184 | |||
185 | e2x = ux - wx; | ||
186 | e2y = uy - wy; | ||
187 | e2z = uz - wz; | ||
188 | |||
189 | |||
190 | // Cross product for normal | ||
191 | float nx, ny, nz; | ||
192 | nx = e1y * e2z - e1z * e2y; | ||
193 | ny = e1z * e2x - e1x * e2z; | ||
194 | nz = e1x * e2y - e1y * e2x; | ||
195 | |||
196 | // Length | ||
197 | float l = (float)Math.Sqrt(nx * nx + ny * ny + nz * nz); | ||
198 | float lReciprocal = 1.0f / l; | ||
199 | |||
200 | // Normalized "normal" | ||
201 | //nx /= l; | ||
202 | //ny /= l; | ||
203 | //nz /= l; | ||
204 | |||
205 | m_normals[i] = nx * lReciprocal; | ||
206 | m_normals[i + 1] = ny * lReciprocal; | ||
207 | m_normals[i + 2] = nz * lReciprocal; | ||
208 | |||
209 | i += 3; | ||
210 | } | ||
211 | } | ||
212 | |||
213 | public List<Vector3> getVertexList() | ||
214 | { | ||
215 | List<Vector3> result = new List<Vector3>(); | ||
216 | foreach (Vertex v in m_vertices.Keys) | ||
217 | { | ||
218 | result.Add(new Vector3(v.X, v.Y, v.Z)); | ||
219 | } | ||
220 | return result; | ||
221 | } | ||
222 | |||
223 | private float[] getVertexListAsFloat() | ||
224 | { | ||
225 | if (m_vertices == null) | ||
226 | throw new NotSupportedException(); | ||
227 | float[] result = new float[m_vertices.Count * 3]; | ||
228 | foreach (KeyValuePair<Vertex, int> kvp in m_vertices) | ||
229 | { | ||
230 | Vertex v = kvp.Key; | ||
231 | int i = kvp.Value; | ||
232 | result[3 * i + 0] = v.X; | ||
233 | result[3 * i + 1] = v.Y; | ||
234 | result[3 * i + 2] = v.Z; | ||
235 | } | ||
236 | return result; | ||
237 | } | ||
238 | |||
239 | public float[] getVertexListAsFloatLocked() | ||
240 | { | ||
241 | if (m_pinnedVertexes.IsAllocated) | ||
242 | return (float[])(m_pinnedVertexes.Target); | ||
243 | |||
244 | float[] result = getVertexListAsFloat(); | ||
245 | m_pinnedVertexes = GCHandle.Alloc(result, GCHandleType.Pinned); | ||
246 | // Inform the garbage collector of this unmanaged allocation so it can schedule | ||
247 | // the next GC round more intelligently | ||
248 | GC.AddMemoryPressure(Buffer.ByteLength(result)); | ||
249 | |||
250 | return result; | ||
251 | } | ||
252 | |||
253 | public void getVertexListAsPtrToFloatArray(out IntPtr vertices, out int vertexStride, out int vertexCount) | ||
254 | { | ||
255 | // A vertex is 3 floats | ||
256 | vertexStride = 3 * sizeof(float); | ||
257 | |||
258 | // If there isn't an unmanaged array allocated yet, do it now | ||
259 | if (m_verticesPtr == IntPtr.Zero) | ||
260 | { | ||
261 | float[] vertexList = getVertexListAsFloat(); | ||
262 | // Each vertex is 3 elements (floats) | ||
263 | m_vertexCount = vertexList.Length / 3; | ||
264 | int byteCount = m_vertexCount * vertexStride; | ||
265 | m_verticesPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(byteCount); | ||
266 | System.Runtime.InteropServices.Marshal.Copy(vertexList, 0, m_verticesPtr, m_vertexCount * 3); | ||
267 | } | ||
268 | vertices = m_verticesPtr; | ||
269 | vertexCount = m_vertexCount; | ||
270 | } | ||
271 | |||
272 | public int[] getIndexListAsInt() | ||
273 | { | ||
274 | if (m_triangles == null) | ||
275 | throw new NotSupportedException(); | ||
276 | int[] result = new int[m_triangles.Count * 3]; | ||
277 | for (int i = 0; i < m_triangles.Count; i++) | ||
278 | { | ||
279 | Triangle t = m_triangles[i]; | ||
280 | result[3 * i + 0] = m_vertices[t.v1]; | ||
281 | result[3 * i + 1] = m_vertices[t.v2]; | ||
282 | result[3 * i + 2] = m_vertices[t.v3]; | ||
283 | } | ||
284 | return result; | ||
285 | } | ||
286 | |||
287 | /// <summary> | ||
288 | /// creates a list of index values that defines triangle faces. THIS METHOD FREES ALL NON-PINNED MESH DATA | ||
289 | /// </summary> | ||
290 | /// <returns></returns> | ||
291 | public int[] getIndexListAsIntLocked() | ||
292 | { | ||
293 | if (m_pinnedIndex.IsAllocated) | ||
294 | return (int[])(m_pinnedIndex.Target); | ||
295 | |||
296 | int[] result = getIndexListAsInt(); | ||
297 | m_pinnedIndex = GCHandle.Alloc(result, GCHandleType.Pinned); | ||
298 | // Inform the garbage collector of this unmanaged allocation so it can schedule | ||
299 | // the next GC round more intelligently | ||
300 | GC.AddMemoryPressure(Buffer.ByteLength(result)); | ||
301 | |||
302 | return result; | ||
303 | } | ||
304 | |||
305 | public void getIndexListAsPtrToIntArray(out IntPtr indices, out int triStride, out int indexCount) | ||
306 | { | ||
307 | // If there isn't an unmanaged array allocated yet, do it now | ||
308 | if (m_indicesPtr == IntPtr.Zero) | ||
309 | { | ||
310 | int[] indexList = getIndexListAsInt(); | ||
311 | m_indexCount = indexList.Length; | ||
312 | int byteCount = m_indexCount * sizeof(int); | ||
313 | m_indicesPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(byteCount); | ||
314 | System.Runtime.InteropServices.Marshal.Copy(indexList, 0, m_indicesPtr, m_indexCount); | ||
315 | } | ||
316 | // A triangle is 3 ints (indices) | ||
317 | triStride = 3 * sizeof(int); | ||
318 | indices = m_indicesPtr; | ||
319 | indexCount = m_indexCount; | ||
320 | } | ||
321 | |||
322 | public void releasePinned() | ||
323 | { | ||
324 | if (m_pinnedVertexes.IsAllocated) | ||
325 | m_pinnedVertexes.Free(); | ||
326 | if (m_pinnedIndex.IsAllocated) | ||
327 | m_pinnedIndex.Free(); | ||
328 | if (m_verticesPtr != IntPtr.Zero) | ||
329 | { | ||
330 | System.Runtime.InteropServices.Marshal.FreeHGlobal(m_verticesPtr); | ||
331 | m_verticesPtr = IntPtr.Zero; | ||
332 | } | ||
333 | if (m_indicesPtr != IntPtr.Zero) | ||
334 | { | ||
335 | System.Runtime.InteropServices.Marshal.FreeHGlobal(m_indicesPtr); | ||
336 | m_indicesPtr = IntPtr.Zero; | ||
337 | } | ||
338 | } | ||
339 | |||
340 | /// <summary> | ||
341 | /// frees up the source mesh data to minimize memory - call this method after calling get*Locked() functions | ||
342 | /// </summary> | ||
343 | public void releaseSourceMeshData() | ||
344 | { | ||
345 | m_triangles = null; | ||
346 | m_vertices = null; | ||
347 | } | ||
348 | |||
349 | public void Append(IMesh newMesh) | ||
350 | { | ||
351 | if (m_pinnedIndex.IsAllocated || m_pinnedVertexes.IsAllocated || m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero) | ||
352 | throw new NotSupportedException("Attempt to Append to a pinned Mesh"); | ||
353 | |||
354 | if (!(newMesh is Mesh)) | ||
355 | return; | ||
356 | |||
357 | foreach (Triangle t in ((Mesh)newMesh).m_triangles) | ||
358 | Add(t); | ||
359 | } | ||
360 | |||
361 | // Do a linear transformation of mesh. | ||
362 | public void TransformLinear(float[,] matrix, float[] offset) | ||
363 | { | ||
364 | if (m_pinnedIndex.IsAllocated || m_pinnedVertexes.IsAllocated || m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero) | ||
365 | throw new NotSupportedException("Attempt to TransformLinear a pinned Mesh"); | ||
366 | |||
367 | foreach (Vertex v in m_vertices.Keys) | ||
368 | { | ||
369 | if (v == null) | ||
370 | continue; | ||
371 | float x, y, z; | ||
372 | x = v.X*matrix[0, 0] + v.Y*matrix[1, 0] + v.Z*matrix[2, 0]; | ||
373 | y = v.X*matrix[0, 1] + v.Y*matrix[1, 1] + v.Z*matrix[2, 1]; | ||
374 | z = v.X*matrix[0, 2] + v.Y*matrix[1, 2] + v.Z*matrix[2, 2]; | ||
375 | v.X = x + offset[0]; | ||
376 | v.Y = y + offset[1]; | ||
377 | v.Z = z + offset[2]; | ||
378 | } | ||
379 | } | ||
380 | |||
381 | public void DumpRaw(String path, String name, String title) | ||
382 | { | ||
383 | if (path == null) | ||
384 | return; | ||
385 | String fileName = name + "_" + title + ".raw"; | ||
386 | String completePath = System.IO.Path.Combine(path, fileName); | ||
387 | StreamWriter sw = new StreamWriter(completePath); | ||
388 | foreach (Triangle t in m_triangles) | ||
389 | { | ||
390 | String s = t.ToStringRaw(); | ||
391 | sw.WriteLine(s); | ||
392 | } | ||
393 | sw.Close(); | ||
394 | } | ||
395 | |||
396 | public void TrimExcess() | ||
397 | { | ||
398 | m_triangles.TrimExcess(); | ||
399 | } | ||
400 | } | ||
401 | } | ||
diff --git a/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs b/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs new file mode 100644 index 0000000..c9c52c0 --- /dev/null +++ b/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs | |||
@@ -0,0 +1,762 @@ | |||
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 | //#define SPAM | ||
28 | |||
29 | using System; | ||
30 | using System.Collections.Generic; | ||
31 | using OpenSim.Framework; | ||
32 | using OpenSim.Region.Physics.Manager; | ||
33 | using OpenMetaverse; | ||
34 | using OpenMetaverse.StructuredData; | ||
35 | using System.Drawing; | ||
36 | using System.Drawing.Imaging; | ||
37 | using System.IO.Compression; | ||
38 | using PrimMesher; | ||
39 | using log4net; | ||
40 | using Nini.Config; | ||
41 | using System.Reflection; | ||
42 | using System.IO; | ||
43 | using ComponentAce.Compression.Libs.zlib; | ||
44 | |||
45 | namespace OpenSim.Region.Physics.Meshing | ||
46 | { | ||
47 | public class MeshmerizerPlugin : IMeshingPlugin | ||
48 | { | ||
49 | public MeshmerizerPlugin() | ||
50 | { | ||
51 | } | ||
52 | |||
53 | public string GetName() | ||
54 | { | ||
55 | return "UbitMeshmerizer"; | ||
56 | } | ||
57 | |||
58 | public IMesher GetMesher(IConfigSource config) | ||
59 | { | ||
60 | return new Meshmerizer(config); | ||
61 | } | ||
62 | } | ||
63 | |||
64 | public class Meshmerizer : IMesher | ||
65 | { | ||
66 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
67 | |||
68 | // Setting baseDir to a path will enable the dumping of raw files | ||
69 | // raw files can be imported by blender so a visual inspection of the results can be done | ||
70 | #if SPAM | ||
71 | const string baseDir = "rawFiles"; | ||
72 | #else | ||
73 | private const string baseDir = null; //"rawFiles"; | ||
74 | #endif | ||
75 | |||
76 | private bool cacheSculptMaps = true; | ||
77 | private bool cacheSculptAlphaMaps = true; | ||
78 | |||
79 | private string decodedSculptMapPath = null; | ||
80 | private bool useMeshiesPhysicsMesh = false; | ||
81 | |||
82 | private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh | ||
83 | |||
84 | private Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>(); | ||
85 | |||
86 | public Meshmerizer(IConfigSource config) | ||
87 | { | ||
88 | IConfig start_config = config.Configs["Startup"]; | ||
89 | IConfig mesh_config = config.Configs["Mesh"]; | ||
90 | |||
91 | decodedSculptMapPath = start_config.GetString("DecodedSculptMapPath","j2kDecodeCache"); | ||
92 | |||
93 | cacheSculptMaps = start_config.GetBoolean("CacheSculptMaps", cacheSculptMaps); | ||
94 | |||
95 | if (Environment.OSVersion.Platform == PlatformID.Unix) | ||
96 | { | ||
97 | cacheSculptAlphaMaps = false; | ||
98 | } | ||
99 | else | ||
100 | cacheSculptAlphaMaps = cacheSculptMaps; | ||
101 | |||
102 | if(mesh_config != null) | ||
103 | useMeshiesPhysicsMesh = mesh_config.GetBoolean("UseMeshiesPhysicsMesh", useMeshiesPhysicsMesh); | ||
104 | |||
105 | try | ||
106 | { | ||
107 | if (!Directory.Exists(decodedSculptMapPath)) | ||
108 | Directory.CreateDirectory(decodedSculptMapPath); | ||
109 | } | ||
110 | catch (Exception e) | ||
111 | { | ||
112 | m_log.WarnFormat("[SCULPT]: Unable to create {0} directory: ", decodedSculptMapPath, e.Message); | ||
113 | } | ||
114 | } | ||
115 | |||
116 | /// <summary> | ||
117 | /// creates a simple box mesh of the specified size. This mesh is of very low vertex count and may | ||
118 | /// be useful as a backup proxy when level of detail is not needed or when more complex meshes fail | ||
119 | /// for some reason | ||
120 | /// </summary> | ||
121 | /// <param name="minX"></param> | ||
122 | /// <param name="maxX"></param> | ||
123 | /// <param name="minY"></param> | ||
124 | /// <param name="maxY"></param> | ||
125 | /// <param name="minZ"></param> | ||
126 | /// <param name="maxZ"></param> | ||
127 | /// <returns></returns> | ||
128 | private static Mesh CreateSimpleBoxMesh(float minX, float maxX, float minY, float maxY, float minZ, float maxZ) | ||
129 | { | ||
130 | Mesh box = new Mesh(); | ||
131 | List<Vertex> vertices = new List<Vertex>(); | ||
132 | // bottom | ||
133 | |||
134 | vertices.Add(new Vertex(minX, maxY, minZ)); | ||
135 | vertices.Add(new Vertex(maxX, maxY, minZ)); | ||
136 | vertices.Add(new Vertex(maxX, minY, minZ)); | ||
137 | vertices.Add(new Vertex(minX, minY, minZ)); | ||
138 | |||
139 | box.Add(new Triangle(vertices[0], vertices[1], vertices[2])); | ||
140 | box.Add(new Triangle(vertices[0], vertices[2], vertices[3])); | ||
141 | |||
142 | // top | ||
143 | |||
144 | vertices.Add(new Vertex(maxX, maxY, maxZ)); | ||
145 | vertices.Add(new Vertex(minX, maxY, maxZ)); | ||
146 | vertices.Add(new Vertex(minX, minY, maxZ)); | ||
147 | vertices.Add(new Vertex(maxX, minY, maxZ)); | ||
148 | |||
149 | box.Add(new Triangle(vertices[4], vertices[5], vertices[6])); | ||
150 | box.Add(new Triangle(vertices[4], vertices[6], vertices[7])); | ||
151 | |||
152 | // sides | ||
153 | |||
154 | box.Add(new Triangle(vertices[5], vertices[0], vertices[3])); | ||
155 | box.Add(new Triangle(vertices[5], vertices[3], vertices[6])); | ||
156 | |||
157 | box.Add(new Triangle(vertices[1], vertices[0], vertices[5])); | ||
158 | box.Add(new Triangle(vertices[1], vertices[5], vertices[4])); | ||
159 | |||
160 | box.Add(new Triangle(vertices[7], vertices[1], vertices[4])); | ||
161 | box.Add(new Triangle(vertices[7], vertices[2], vertices[1])); | ||
162 | |||
163 | box.Add(new Triangle(vertices[3], vertices[2], vertices[7])); | ||
164 | box.Add(new Triangle(vertices[3], vertices[7], vertices[6])); | ||
165 | |||
166 | return box; | ||
167 | } | ||
168 | |||
169 | /// <summary> | ||
170 | /// Creates a simple bounding box mesh for a complex input mesh | ||
171 | /// </summary> | ||
172 | /// <param name="meshIn"></param> | ||
173 | /// <returns></returns> | ||
174 | private static Mesh CreateBoundingBoxMesh(Mesh meshIn) | ||
175 | { | ||
176 | float minX = float.MaxValue; | ||
177 | float maxX = float.MinValue; | ||
178 | float minY = float.MaxValue; | ||
179 | float maxY = float.MinValue; | ||
180 | float minZ = float.MaxValue; | ||
181 | float maxZ = float.MinValue; | ||
182 | |||
183 | foreach (Vector3 v in meshIn.getVertexList()) | ||
184 | { | ||
185 | if (v.X < minX) minX = v.X; | ||
186 | if (v.Y < minY) minY = v.Y; | ||
187 | if (v.Z < minZ) minZ = v.Z; | ||
188 | |||
189 | if (v.X > maxX) maxX = v.X; | ||
190 | if (v.Y > maxY) maxY = v.Y; | ||
191 | if (v.Z > maxZ) maxZ = v.Z; | ||
192 | } | ||
193 | |||
194 | return CreateSimpleBoxMesh(minX, maxX, minY, maxY, minZ, maxZ); | ||
195 | } | ||
196 | |||
197 | private void ReportPrimError(string message, string primName, PrimMesh primMesh) | ||
198 | { | ||
199 | m_log.Error(message); | ||
200 | m_log.Error("\nPrim Name: " + primName); | ||
201 | m_log.Error("****** PrimMesh Parameters ******\n" + primMesh.ParamsToDisplayString()); | ||
202 | } | ||
203 | |||
204 | /// <summary> | ||
205 | /// Add a submesh to an existing list of coords and faces. | ||
206 | /// </summary> | ||
207 | /// <param name="subMeshData"></param> | ||
208 | /// <param name="size">Size of entire object</param> | ||
209 | /// <param name="coords"></param> | ||
210 | /// <param name="faces"></param> | ||
211 | private void AddSubMesh(OSDMap subMeshData, Vector3 size, List<Coord> coords, List<Face> faces) | ||
212 | { | ||
213 | // Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap)); | ||
214 | |||
215 | // As per http://wiki.secondlife.com/wiki/Mesh/Mesh_Asset_Format, some Mesh Level | ||
216 | // of Detail Blocks (maps) contain just a NoGeometry key to signal there is no | ||
217 | // geometry for this submesh. | ||
218 | if (subMeshData.ContainsKey("NoGeometry") && ((OSDBoolean)subMeshData["NoGeometry"])) | ||
219 | return; | ||
220 | |||
221 | OpenMetaverse.Vector3 posMax = ((OSDMap)subMeshData["PositionDomain"])["Max"].AsVector3(); | ||
222 | OpenMetaverse.Vector3 posMin = ((OSDMap)subMeshData["PositionDomain"])["Min"].AsVector3(); | ||
223 | ushort faceIndexOffset = (ushort)coords.Count; | ||
224 | |||
225 | byte[] posBytes = subMeshData["Position"].AsBinary(); | ||
226 | for (int i = 0; i < posBytes.Length; i += 6) | ||
227 | { | ||
228 | ushort uX = Utils.BytesToUInt16(posBytes, i); | ||
229 | ushort uY = Utils.BytesToUInt16(posBytes, i + 2); | ||
230 | ushort uZ = Utils.BytesToUInt16(posBytes, i + 4); | ||
231 | |||
232 | Coord c = new Coord( | ||
233 | Utils.UInt16ToFloat(uX, posMin.X, posMax.X) * size.X, | ||
234 | Utils.UInt16ToFloat(uY, posMin.Y, posMax.Y) * size.Y, | ||
235 | Utils.UInt16ToFloat(uZ, posMin.Z, posMax.Z) * size.Z); | ||
236 | |||
237 | coords.Add(c); | ||
238 | } | ||
239 | |||
240 | byte[] triangleBytes = subMeshData["TriangleList"].AsBinary(); | ||
241 | for (int i = 0; i < triangleBytes.Length; i += 6) | ||
242 | { | ||
243 | ushort v1 = (ushort)(Utils.BytesToUInt16(triangleBytes, i) + faceIndexOffset); | ||
244 | ushort v2 = (ushort)(Utils.BytesToUInt16(triangleBytes, i + 2) + faceIndexOffset); | ||
245 | ushort v3 = (ushort)(Utils.BytesToUInt16(triangleBytes, i + 4) + faceIndexOffset); | ||
246 | Face f = new Face(v1, v2, v3); | ||
247 | faces.Add(f); | ||
248 | } | ||
249 | } | ||
250 | |||
251 | /// <summary> | ||
252 | /// Create a physics mesh from data that comes with the prim. The actual data used depends on the prim type. | ||
253 | /// </summary> | ||
254 | /// <param name="primName"></param> | ||
255 | /// <param name="primShape"></param> | ||
256 | /// <param name="size"></param> | ||
257 | /// <param name="lod"></param> | ||
258 | /// <returns></returns> | ||
259 | private Mesh CreateMeshFromPrimMesher(string primName, PrimitiveBaseShape primShape, Vector3 size, float lod) | ||
260 | { | ||
261 | // m_log.DebugFormat( | ||
262 | // "[MESH]: Creating physics proxy for {0}, shape {1}", | ||
263 | // primName, (OpenMetaverse.SculptType)primShape.SculptType); | ||
264 | |||
265 | List<Coord> coords; | ||
266 | List<Face> faces; | ||
267 | |||
268 | if (primShape.SculptEntry) | ||
269 | { | ||
270 | if (((OpenMetaverse.SculptType)primShape.SculptType) == SculptType.Mesh) | ||
271 | { | ||
272 | if (!useMeshiesPhysicsMesh) | ||
273 | return null; | ||
274 | |||
275 | if (!GenerateCoordsAndFacesFromPrimMeshData(primName, primShape, size, out coords, out faces)) | ||
276 | return null; | ||
277 | } | ||
278 | else | ||
279 | { | ||
280 | if (!GenerateCoordsAndFacesFromPrimSculptData(primName, primShape, size, lod, out coords, out faces)) | ||
281 | return null; | ||
282 | // Remove the reference to any JPEG2000 sculpt data so it can be GCed | ||
283 | // don't loose it | ||
284 | // primShape.SculptData = Utils.EmptyBytes; | ||
285 | } | ||
286 | // primShape.SculptDataLoaded = true; | ||
287 | } | ||
288 | else | ||
289 | { | ||
290 | if (!GenerateCoordsAndFacesFromPrimShapeData(primName, primShape, size, lod, out coords, out faces)) | ||
291 | return null; | ||
292 | } | ||
293 | // keep compatible | ||
294 | primShape.SculptData = Utils.EmptyBytes; | ||
295 | |||
296 | int numCoords = coords.Count; | ||
297 | int numFaces = faces.Count; | ||
298 | |||
299 | // Create the list of vertices | ||
300 | List<Vertex> vertices = new List<Vertex>(); | ||
301 | for (int i = 0; i < numCoords; i++) | ||
302 | { | ||
303 | Coord c = coords[i]; | ||
304 | vertices.Add(new Vertex(c.X, c.Y, c.Z)); | ||
305 | } | ||
306 | |||
307 | Mesh mesh = new Mesh(); | ||
308 | // Add the corresponding triangles to the mesh | ||
309 | for (int i = 0; i < numFaces; i++) | ||
310 | { | ||
311 | Face f = faces[i]; | ||
312 | mesh.Add(new Triangle(vertices[f.v1], vertices[f.v2], vertices[f.v3])); | ||
313 | } | ||
314 | |||
315 | return mesh; | ||
316 | } | ||
317 | |||
318 | /// <summary> | ||
319 | /// Generate the co-ords and faces necessary to construct a mesh from the mesh data the accompanies a prim. | ||
320 | /// </summary> | ||
321 | /// <param name="primName"></param> | ||
322 | /// <param name="primShape"></param> | ||
323 | /// <param name="size"></param> | ||
324 | /// <param name="coords">Coords are added to this list by the method.</param> | ||
325 | /// <param name="faces">Faces are added to this list by the method.</param> | ||
326 | /// <returns>true if coords and faces were successfully generated, false if not</returns> | ||
327 | private bool GenerateCoordsAndFacesFromPrimMeshData( | ||
328 | string primName, PrimitiveBaseShape primShape, Vector3 size, out List<Coord> coords, out List<Face> faces) | ||
329 | { | ||
330 | // m_log.DebugFormat("[MESH]: experimental mesh proxy generation for {0}", primName); | ||
331 | |||
332 | coords = new List<Coord>(); | ||
333 | faces = new List<Face>(); | ||
334 | OSD meshOsd = null; | ||
335 | |||
336 | if (primShape.SculptData.Length <= 0) | ||
337 | { | ||
338 | m_log.ErrorFormat("[MESH]: asset data for {0} is zero length", primName); | ||
339 | return false; | ||
340 | } | ||
341 | |||
342 | long start = 0; | ||
343 | using (MemoryStream data = new MemoryStream(primShape.SculptData)) | ||
344 | { | ||
345 | try | ||
346 | { | ||
347 | OSD osd = OSDParser.DeserializeLLSDBinary(data); | ||
348 | if (osd is OSDMap) | ||
349 | meshOsd = (OSDMap)osd; | ||
350 | else | ||
351 | { | ||
352 | m_log.Warn("[Mesh}: unable to cast mesh asset to OSDMap"); | ||
353 | return false; | ||
354 | } | ||
355 | } | ||
356 | catch (Exception e) | ||
357 | { | ||
358 | m_log.Error("[MESH]: Exception deserializing mesh asset header:" + e.ToString()); | ||
359 | } | ||
360 | |||
361 | start = data.Position; | ||
362 | } | ||
363 | |||
364 | if (meshOsd is OSDMap) | ||
365 | { | ||
366 | OSDMap physicsParms = null; | ||
367 | OSDMap map = (OSDMap)meshOsd; | ||
368 | if (map.ContainsKey("physics_shape")) | ||
369 | physicsParms = (OSDMap)map["physics_shape"]; // old asset format | ||
370 | else if (map.ContainsKey("physics_mesh")) | ||
371 | physicsParms = (OSDMap)map["physics_mesh"]; // new asset format | ||
372 | |||
373 | if (physicsParms == null) | ||
374 | { | ||
375 | m_log.Warn("[MESH]: no recognized physics mesh found in mesh asset"); | ||
376 | return false; | ||
377 | } | ||
378 | |||
379 | int physOffset = physicsParms["offset"].AsInteger() + (int)start; | ||
380 | int physSize = physicsParms["size"].AsInteger(); | ||
381 | |||
382 | if (physOffset < 0 || physSize == 0) | ||
383 | return false; // no mesh data in asset | ||
384 | |||
385 | OSD decodedMeshOsd = new OSD(); | ||
386 | byte[] meshBytes = new byte[physSize]; | ||
387 | System.Buffer.BlockCopy(primShape.SculptData, physOffset, meshBytes, 0, physSize); | ||
388 | // byte[] decompressed = new byte[physSize * 5]; | ||
389 | try | ||
390 | { | ||
391 | using (MemoryStream inMs = new MemoryStream(meshBytes)) | ||
392 | { | ||
393 | using (MemoryStream outMs = new MemoryStream()) | ||
394 | { | ||
395 | using (ZOutputStream zOut = new ZOutputStream(outMs)) | ||
396 | { | ||
397 | byte[] readBuffer = new byte[2048]; | ||
398 | int readLen = 0; | ||
399 | while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0) | ||
400 | { | ||
401 | zOut.Write(readBuffer, 0, readLen); | ||
402 | } | ||
403 | zOut.Flush(); | ||
404 | outMs.Seek(0, SeekOrigin.Begin); | ||
405 | |||
406 | byte[] decompressedBuf = outMs.GetBuffer(); | ||
407 | |||
408 | decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf); | ||
409 | } | ||
410 | } | ||
411 | } | ||
412 | } | ||
413 | catch (Exception e) | ||
414 | { | ||
415 | m_log.Error("[MESH]: exception decoding physical mesh: " + e.ToString()); | ||
416 | return false; | ||
417 | } | ||
418 | |||
419 | OSDArray decodedMeshOsdArray = null; | ||
420 | |||
421 | // physics_shape is an array of OSDMaps, one for each submesh | ||
422 | if (decodedMeshOsd is OSDArray) | ||
423 | { | ||
424 | // Console.WriteLine("decodedMeshOsd for {0} - {1}", primName, Util.GetFormattedXml(decodedMeshOsd)); | ||
425 | |||
426 | decodedMeshOsdArray = (OSDArray)decodedMeshOsd; | ||
427 | foreach (OSD subMeshOsd in decodedMeshOsdArray) | ||
428 | { | ||
429 | if (subMeshOsd is OSDMap) | ||
430 | AddSubMesh(subMeshOsd as OSDMap, size, coords, faces); | ||
431 | } | ||
432 | } | ||
433 | } | ||
434 | |||
435 | return true; | ||
436 | } | ||
437 | |||
438 | /// <summary> | ||
439 | /// Generate the co-ords and faces necessary to construct a mesh from the sculpt data the accompanies a prim. | ||
440 | /// </summary> | ||
441 | /// <param name="primName"></param> | ||
442 | /// <param name="primShape"></param> | ||
443 | /// <param name="size"></param> | ||
444 | /// <param name="lod"></param> | ||
445 | /// <param name="coords">Coords are added to this list by the method.</param> | ||
446 | /// <param name="faces">Faces are added to this list by the method.</param> | ||
447 | /// <returns>true if coords and faces were successfully generated, false if not</returns> | ||
448 | private bool GenerateCoordsAndFacesFromPrimSculptData( | ||
449 | string primName, PrimitiveBaseShape primShape, Vector3 size, float lod, out List<Coord> coords, out List<Face> faces) | ||
450 | { | ||
451 | coords = new List<Coord>(); | ||
452 | faces = new List<Face>(); | ||
453 | PrimMesher.SculptMesh sculptMesh; | ||
454 | Image idata = null; | ||
455 | string decodedSculptFileName = ""; | ||
456 | |||
457 | if (cacheSculptMaps && primShape.SculptTexture != UUID.Zero) | ||
458 | { | ||
459 | decodedSculptFileName = System.IO.Path.Combine(decodedSculptMapPath, "smap_" + primShape.SculptTexture.ToString()); | ||
460 | try | ||
461 | { | ||
462 | if (File.Exists(decodedSculptFileName)) | ||
463 | { | ||
464 | idata = Image.FromFile(decodedSculptFileName); | ||
465 | } | ||
466 | } | ||
467 | catch (Exception e) | ||
468 | { | ||
469 | m_log.Error("[SCULPT]: unable to load cached sculpt map " + decodedSculptFileName + " " + e.Message); | ||
470 | |||
471 | } | ||
472 | //if (idata != null) | ||
473 | // m_log.Debug("[SCULPT]: loaded cached map asset for map ID: " + primShape.SculptTexture.ToString()); | ||
474 | } | ||
475 | |||
476 | if (idata == null) | ||
477 | { | ||
478 | if (primShape.SculptData == null || primShape.SculptData.Length == 0) | ||
479 | return false; | ||
480 | |||
481 | try | ||
482 | { | ||
483 | OpenMetaverse.Imaging.ManagedImage unusedData; | ||
484 | OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(primShape.SculptData, out unusedData, out idata); | ||
485 | |||
486 | if (idata == null) | ||
487 | { | ||
488 | // In some cases it seems that the decode can return a null bitmap without throwing | ||
489 | // an exception | ||
490 | m_log.WarnFormat("[PHYSICS]: OpenJPEG decoded sculpt data for {0} to a null bitmap. Ignoring.", primName); | ||
491 | |||
492 | return false; | ||
493 | } | ||
494 | |||
495 | unusedData = null; | ||
496 | |||
497 | //idata = CSJ2K.J2kImage.FromBytes(primShape.SculptData); | ||
498 | |||
499 | if (cacheSculptMaps && (cacheSculptAlphaMaps || (((ImageFlags)(idata.Flags) & ImageFlags.HasAlpha) ==0))) | ||
500 | // don't cache images with alpha channel in linux since mono can't load them correctly) | ||
501 | { | ||
502 | try { idata.Save(decodedSculptFileName, ImageFormat.MemoryBmp); } | ||
503 | catch (Exception e) { m_log.Error("[SCULPT]: unable to cache sculpt map " + decodedSculptFileName + " " + e.Message); } | ||
504 | } | ||
505 | } | ||
506 | catch (DllNotFoundException) | ||
507 | { | ||
508 | m_log.Error("[PHYSICS]: OpenJpeg is not installed correctly on this system. Physics Proxy generation failed. Often times this is because of an old version of GLIBC. You must have version 2.4 or above!"); | ||
509 | return false; | ||
510 | } | ||
511 | catch (IndexOutOfRangeException) | ||
512 | { | ||
513 | m_log.Error("[PHYSICS]: OpenJpeg was unable to decode this. Physics Proxy generation failed"); | ||
514 | return false; | ||
515 | } | ||
516 | catch (Exception ex) | ||
517 | { | ||
518 | m_log.Error("[PHYSICS]: Unable to generate a Sculpty physics proxy. Sculpty texture decode failed: " + ex.Message); | ||
519 | return false; | ||
520 | } | ||
521 | } | ||
522 | |||
523 | PrimMesher.SculptMesh.SculptType sculptType; | ||
524 | switch ((OpenMetaverse.SculptType)primShape.SculptType) | ||
525 | { | ||
526 | case OpenMetaverse.SculptType.Cylinder: | ||
527 | sculptType = PrimMesher.SculptMesh.SculptType.cylinder; | ||
528 | break; | ||
529 | case OpenMetaverse.SculptType.Plane: | ||
530 | sculptType = PrimMesher.SculptMesh.SculptType.plane; | ||
531 | break; | ||
532 | case OpenMetaverse.SculptType.Torus: | ||
533 | sculptType = PrimMesher.SculptMesh.SculptType.torus; | ||
534 | break; | ||
535 | case OpenMetaverse.SculptType.Sphere: | ||
536 | sculptType = PrimMesher.SculptMesh.SculptType.sphere; | ||
537 | break; | ||
538 | default: | ||
539 | sculptType = PrimMesher.SculptMesh.SculptType.plane; | ||
540 | break; | ||
541 | } | ||
542 | |||
543 | bool mirror = ((primShape.SculptType & 128) != 0); | ||
544 | bool invert = ((primShape.SculptType & 64) != 0); | ||
545 | |||
546 | sculptMesh = new PrimMesher.SculptMesh((Bitmap)idata, sculptType, (int)lod, false, mirror, invert); | ||
547 | |||
548 | idata.Dispose(); | ||
549 | |||
550 | sculptMesh.DumpRaw(baseDir, primName, "primMesh"); | ||
551 | |||
552 | sculptMesh.Scale(size.X, size.Y, size.Z); | ||
553 | |||
554 | coords = sculptMesh.coords; | ||
555 | faces = sculptMesh.faces; | ||
556 | |||
557 | return true; | ||
558 | } | ||
559 | |||
560 | /// <summary> | ||
561 | /// Generate the co-ords and faces necessary to construct a mesh from the shape data the accompanies a prim. | ||
562 | /// </summary> | ||
563 | /// <param name="primName"></param> | ||
564 | /// <param name="primShape"></param> | ||
565 | /// <param name="size"></param> | ||
566 | /// <param name="coords">Coords are added to this list by the method.</param> | ||
567 | /// <param name="faces">Faces are added to this list by the method.</param> | ||
568 | /// <returns>true if coords and faces were successfully generated, false if not</returns> | ||
569 | private bool GenerateCoordsAndFacesFromPrimShapeData( | ||
570 | string primName, PrimitiveBaseShape primShape, Vector3 size, float lod, out List<Coord> coords, out List<Face> faces) | ||
571 | { | ||
572 | PrimMesh primMesh; | ||
573 | coords = new List<Coord>(); | ||
574 | faces = new List<Face>(); | ||
575 | |||
576 | float pathShearX = primShape.PathShearX < 128 ? (float)primShape.PathShearX * 0.01f : (float)(primShape.PathShearX - 256) * 0.01f; | ||
577 | float pathShearY = primShape.PathShearY < 128 ? (float)primShape.PathShearY * 0.01f : (float)(primShape.PathShearY - 256) * 0.01f; | ||
578 | float pathBegin = (float)primShape.PathBegin * 2.0e-5f; | ||
579 | float pathEnd = 1.0f - (float)primShape.PathEnd * 2.0e-5f; | ||
580 | float pathScaleX = (float)(primShape.PathScaleX - 100) * 0.01f; | ||
581 | float pathScaleY = (float)(primShape.PathScaleY - 100) * 0.01f; | ||
582 | |||
583 | float profileBegin = (float)primShape.ProfileBegin * 2.0e-5f; | ||
584 | float profileEnd = 1.0f - (float)primShape.ProfileEnd * 2.0e-5f; | ||
585 | float profileHollow = (float)primShape.ProfileHollow * 2.0e-5f; | ||
586 | if (profileHollow > 0.95f) | ||
587 | profileHollow = 0.95f; | ||
588 | |||
589 | int sides = 4; | ||
590 | LevelOfDetail iLOD = (LevelOfDetail)lod; | ||
591 | if ((primShape.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle) | ||
592 | sides = 3; | ||
593 | else if ((primShape.ProfileCurve & 0x07) == (byte)ProfileShape.Circle) | ||
594 | { | ||
595 | switch (iLOD) | ||
596 | { | ||
597 | case LevelOfDetail.High: sides = 24; break; | ||
598 | case LevelOfDetail.Medium: sides = 12; break; | ||
599 | case LevelOfDetail.Low: sides = 6; break; | ||
600 | case LevelOfDetail.VeryLow: sides = 3; break; | ||
601 | default: sides = 24; break; | ||
602 | } | ||
603 | } | ||
604 | else if ((primShape.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle) | ||
605 | { // half circle, prim is a sphere | ||
606 | switch (iLOD) | ||
607 | { | ||
608 | case LevelOfDetail.High: sides = 24; break; | ||
609 | case LevelOfDetail.Medium: sides = 12; break; | ||
610 | case LevelOfDetail.Low: sides = 6; break; | ||
611 | case LevelOfDetail.VeryLow: sides = 3; break; | ||
612 | default: sides = 24; break; | ||
613 | } | ||
614 | |||
615 | profileBegin = 0.5f * profileBegin + 0.5f; | ||
616 | profileEnd = 0.5f * profileEnd + 0.5f; | ||
617 | } | ||
618 | |||
619 | int hollowSides = sides; | ||
620 | if (primShape.HollowShape == HollowShape.Circle) | ||
621 | { | ||
622 | switch (iLOD) | ||
623 | { | ||
624 | case LevelOfDetail.High: hollowSides = 24; break; | ||
625 | case LevelOfDetail.Medium: hollowSides = 12; break; | ||
626 | case LevelOfDetail.Low: hollowSides = 6; break; | ||
627 | case LevelOfDetail.VeryLow: hollowSides = 3; break; | ||
628 | default: hollowSides = 24; break; | ||
629 | } | ||
630 | } | ||
631 | else if (primShape.HollowShape == HollowShape.Square) | ||
632 | hollowSides = 4; | ||
633 | else if (primShape.HollowShape == HollowShape.Triangle) | ||
634 | hollowSides = 3; | ||
635 | |||
636 | primMesh = new PrimMesh(sides, profileBegin, profileEnd, profileHollow, hollowSides); | ||
637 | |||
638 | if (primMesh.errorMessage != null) | ||
639 | if (primMesh.errorMessage.Length > 0) | ||
640 | m_log.Error("[ERROR] " + primMesh.errorMessage); | ||
641 | |||
642 | primMesh.topShearX = pathShearX; | ||
643 | primMesh.topShearY = pathShearY; | ||
644 | primMesh.pathCutBegin = pathBegin; | ||
645 | primMesh.pathCutEnd = pathEnd; | ||
646 | |||
647 | if (primShape.PathCurve == (byte)Extrusion.Straight || primShape.PathCurve == (byte) Extrusion.Flexible) | ||
648 | { | ||
649 | primMesh.twistBegin = primShape.PathTwistBegin * 18 / 10; | ||
650 | primMesh.twistEnd = primShape.PathTwist * 18 / 10; | ||
651 | primMesh.taperX = pathScaleX; | ||
652 | primMesh.taperY = pathScaleY; | ||
653 | |||
654 | if (profileBegin < 0.0f || profileBegin >= profileEnd || profileEnd > 1.0f) | ||
655 | { | ||
656 | ReportPrimError("*** CORRUPT PRIM!! ***", primName, primMesh); | ||
657 | if (profileBegin < 0.0f) profileBegin = 0.0f; | ||
658 | if (profileEnd > 1.0f) profileEnd = 1.0f; | ||
659 | } | ||
660 | #if SPAM | ||
661 | m_log.Debug("****** PrimMesh Parameters (Linear) ******\n" + primMesh.ParamsToDisplayString()); | ||
662 | #endif | ||
663 | try | ||
664 | { | ||
665 | primMesh.ExtrudeLinear(); | ||
666 | } | ||
667 | catch (Exception ex) | ||
668 | { | ||
669 | ReportPrimError("Extrusion failure: exception: " + ex.ToString(), primName, primMesh); | ||
670 | return false; | ||
671 | } | ||
672 | } | ||
673 | else | ||
674 | { | ||
675 | primMesh.holeSizeX = (200 - primShape.PathScaleX) * 0.01f; | ||
676 | primMesh.holeSizeY = (200 - primShape.PathScaleY) * 0.01f; | ||
677 | primMesh.radius = 0.01f * primShape.PathRadiusOffset; | ||
678 | primMesh.revolutions = 1.0f + 0.015f * primShape.PathRevolutions; | ||
679 | primMesh.skew = 0.01f * primShape.PathSkew; | ||
680 | primMesh.twistBegin = primShape.PathTwistBegin * 36 / 10; | ||
681 | primMesh.twistEnd = primShape.PathTwist * 36 / 10; | ||
682 | primMesh.taperX = primShape.PathTaperX * 0.01f; | ||
683 | primMesh.taperY = primShape.PathTaperY * 0.01f; | ||
684 | |||
685 | if (profileBegin < 0.0f || profileBegin >= profileEnd || profileEnd > 1.0f) | ||
686 | { | ||
687 | ReportPrimError("*** CORRUPT PRIM!! ***", primName, primMesh); | ||
688 | if (profileBegin < 0.0f) profileBegin = 0.0f; | ||
689 | if (profileEnd > 1.0f) profileEnd = 1.0f; | ||
690 | } | ||
691 | #if SPAM | ||
692 | m_log.Debug("****** PrimMesh Parameters (Circular) ******\n" + primMesh.ParamsToDisplayString()); | ||
693 | #endif | ||
694 | try | ||
695 | { | ||
696 | primMesh.ExtrudeCircular(); | ||
697 | } | ||
698 | catch (Exception ex) | ||
699 | { | ||
700 | ReportPrimError("Extrusion failure: exception: " + ex.ToString(), primName, primMesh); | ||
701 | return false; | ||
702 | } | ||
703 | } | ||
704 | |||
705 | primMesh.DumpRaw(baseDir, primName, "primMesh"); | ||
706 | |||
707 | primMesh.Scale(size.X, size.Y, size.Z); | ||
708 | |||
709 | coords = primMesh.coords; | ||
710 | faces = primMesh.faces; | ||
711 | |||
712 | return true; | ||
713 | } | ||
714 | |||
715 | public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod) | ||
716 | { | ||
717 | return CreateMesh(primName, primShape, size, lod, false); | ||
718 | } | ||
719 | |||
720 | public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical) | ||
721 | { | ||
722 | #if SPAM | ||
723 | m_log.DebugFormat("[MESH]: Creating mesh for {0}", primName); | ||
724 | #endif | ||
725 | |||
726 | Mesh mesh = null; | ||
727 | ulong key = 0; | ||
728 | |||
729 | // If this mesh has been created already, return it instead of creating another copy | ||
730 | // For large regions with 100k+ prims and hundreds of copies of each, this can save a GB or more of memory | ||
731 | key = primShape.GetMeshKey(size, lod); | ||
732 | if (m_uniqueMeshes.TryGetValue(key, out mesh)) | ||
733 | return mesh; | ||
734 | |||
735 | if (size.X < 0.01f) size.X = 0.01f; | ||
736 | if (size.Y < 0.01f) size.Y = 0.01f; | ||
737 | if (size.Z < 0.01f) size.Z = 0.01f; | ||
738 | |||
739 | mesh = CreateMeshFromPrimMesher(primName, primShape, size, lod); | ||
740 | |||
741 | if (mesh != null) | ||
742 | { | ||
743 | if ((!isPhysical) && size.X < minSizeForComplexMesh && size.Y < minSizeForComplexMesh && size.Z < minSizeForComplexMesh) | ||
744 | { | ||
745 | #if SPAM | ||
746 | m_log.Debug("Meshmerizer: prim " + primName + " has a size of " + size.ToString() + " which is below threshold of " + | ||
747 | minSizeForComplexMesh.ToString() + " - creating simple bounding box"); | ||
748 | #endif | ||
749 | mesh = CreateBoundingBoxMesh(mesh); | ||
750 | mesh.DumpRaw(baseDir, primName, "Z extruded"); | ||
751 | } | ||
752 | |||
753 | // trim the vertex and triangle lists to free up memory | ||
754 | mesh.TrimExcess(); | ||
755 | |||
756 | m_uniqueMeshes.Add(key, mesh); | ||
757 | } | ||
758 | |||
759 | return mesh; | ||
760 | } | ||
761 | } | ||
762 | } | ||
diff --git a/OpenSim/Region/Physics/UbitMeshing/PrimMesher.cs b/OpenSim/Region/Physics/UbitMeshing/PrimMesher.cs new file mode 100644 index 0000000..53022ad --- /dev/null +++ b/OpenSim/Region/Physics/UbitMeshing/PrimMesher.cs | |||
@@ -0,0 +1,2284 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors | ||
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.Text; | ||
31 | using System.IO; | ||
32 | |||
33 | namespace PrimMesher | ||
34 | { | ||
35 | public struct Quat | ||
36 | { | ||
37 | /// <summary>X value</summary> | ||
38 | public float X; | ||
39 | /// <summary>Y value</summary> | ||
40 | public float Y; | ||
41 | /// <summary>Z value</summary> | ||
42 | public float Z; | ||
43 | /// <summary>W value</summary> | ||
44 | public float W; | ||
45 | |||
46 | public Quat(float x, float y, float z, float w) | ||
47 | { | ||
48 | X = x; | ||
49 | Y = y; | ||
50 | Z = z; | ||
51 | W = w; | ||
52 | } | ||
53 | |||
54 | public Quat(Coord axis, float angle) | ||
55 | { | ||
56 | axis = axis.Normalize(); | ||
57 | |||
58 | angle *= 0.5f; | ||
59 | float c = (float)Math.Cos(angle); | ||
60 | float s = (float)Math.Sin(angle); | ||
61 | |||
62 | X = axis.X * s; | ||
63 | Y = axis.Y * s; | ||
64 | Z = axis.Z * s; | ||
65 | W = c; | ||
66 | |||
67 | Normalize(); | ||
68 | } | ||
69 | |||
70 | public float Length() | ||
71 | { | ||
72 | return (float)Math.Sqrt(X * X + Y * Y + Z * Z + W * W); | ||
73 | } | ||
74 | |||
75 | public Quat Normalize() | ||
76 | { | ||
77 | const float MAG_THRESHOLD = 0.0000001f; | ||
78 | float mag = Length(); | ||
79 | |||
80 | // Catch very small rounding errors when normalizing | ||
81 | if (mag > MAG_THRESHOLD) | ||
82 | { | ||
83 | float oomag = 1f / mag; | ||
84 | X *= oomag; | ||
85 | Y *= oomag; | ||
86 | Z *= oomag; | ||
87 | W *= oomag; | ||
88 | } | ||
89 | else | ||
90 | { | ||
91 | X = 0f; | ||
92 | Y = 0f; | ||
93 | Z = 0f; | ||
94 | W = 1f; | ||
95 | } | ||
96 | |||
97 | return this; | ||
98 | } | ||
99 | |||
100 | public static Quat operator *(Quat q1, Quat q2) | ||
101 | { | ||
102 | float x = q1.W * q2.X + q1.X * q2.W + q1.Y * q2.Z - q1.Z * q2.Y; | ||
103 | float y = q1.W * q2.Y - q1.X * q2.Z + q1.Y * q2.W + q1.Z * q2.X; | ||
104 | float z = q1.W * q2.Z + q1.X * q2.Y - q1.Y * q2.X + q1.Z * q2.W; | ||
105 | float w = q1.W * q2.W - q1.X * q2.X - q1.Y * q2.Y - q1.Z * q2.Z; | ||
106 | return new Quat(x, y, z, w); | ||
107 | } | ||
108 | |||
109 | public override string ToString() | ||
110 | { | ||
111 | return "< X: " + this.X.ToString() + ", Y: " + this.Y.ToString() + ", Z: " + this.Z.ToString() + ", W: " + this.W.ToString() + ">"; | ||
112 | } | ||
113 | } | ||
114 | |||
115 | public struct Coord | ||
116 | { | ||
117 | public float X; | ||
118 | public float Y; | ||
119 | public float Z; | ||
120 | |||
121 | public Coord(float x, float y, float z) | ||
122 | { | ||
123 | this.X = x; | ||
124 | this.Y = y; | ||
125 | this.Z = z; | ||
126 | } | ||
127 | |||
128 | public float Length() | ||
129 | { | ||
130 | return (float)Math.Sqrt(this.X * this.X + this.Y * this.Y + this.Z * this.Z); | ||
131 | } | ||
132 | |||
133 | public Coord Invert() | ||
134 | { | ||
135 | this.X = -this.X; | ||
136 | this.Y = -this.Y; | ||
137 | this.Z = -this.Z; | ||
138 | |||
139 | return this; | ||
140 | } | ||
141 | |||
142 | public Coord Normalize() | ||
143 | { | ||
144 | const float MAG_THRESHOLD = 0.0000001f; | ||
145 | float mag = Length(); | ||
146 | |||
147 | // Catch very small rounding errors when normalizing | ||
148 | if (mag > MAG_THRESHOLD) | ||
149 | { | ||
150 | float oomag = 1.0f / mag; | ||
151 | this.X *= oomag; | ||
152 | this.Y *= oomag; | ||
153 | this.Z *= oomag; | ||
154 | } | ||
155 | else | ||
156 | { | ||
157 | this.X = 0.0f; | ||
158 | this.Y = 0.0f; | ||
159 | this.Z = 0.0f; | ||
160 | } | ||
161 | |||
162 | return this; | ||
163 | } | ||
164 | |||
165 | public override string ToString() | ||
166 | { | ||
167 | return this.X.ToString() + " " + this.Y.ToString() + " " + this.Z.ToString(); | ||
168 | } | ||
169 | |||
170 | public static Coord Cross(Coord c1, Coord c2) | ||
171 | { | ||
172 | return new Coord( | ||
173 | c1.Y * c2.Z - c2.Y * c1.Z, | ||
174 | c1.Z * c2.X - c2.Z * c1.X, | ||
175 | c1.X * c2.Y - c2.X * c1.Y | ||
176 | ); | ||
177 | } | ||
178 | |||
179 | public static Coord operator +(Coord v, Coord a) | ||
180 | { | ||
181 | return new Coord(v.X + a.X, v.Y + a.Y, v.Z + a.Z); | ||
182 | } | ||
183 | |||
184 | public static Coord operator *(Coord v, Coord m) | ||
185 | { | ||
186 | return new Coord(v.X * m.X, v.Y * m.Y, v.Z * m.Z); | ||
187 | } | ||
188 | |||
189 | public static Coord operator *(Coord v, Quat q) | ||
190 | { | ||
191 | // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/ | ||
192 | |||
193 | Coord c2 = new Coord(0.0f, 0.0f, 0.0f); | ||
194 | |||
195 | c2.X = q.W * q.W * v.X + | ||
196 | 2f * q.Y * q.W * v.Z - | ||
197 | 2f * q.Z * q.W * v.Y + | ||
198 | q.X * q.X * v.X + | ||
199 | 2f * q.Y * q.X * v.Y + | ||
200 | 2f * q.Z * q.X * v.Z - | ||
201 | q.Z * q.Z * v.X - | ||
202 | q.Y * q.Y * v.X; | ||
203 | |||
204 | c2.Y = | ||
205 | 2f * q.X * q.Y * v.X + | ||
206 | q.Y * q.Y * v.Y + | ||
207 | 2f * q.Z * q.Y * v.Z + | ||
208 | 2f * q.W * q.Z * v.X - | ||
209 | q.Z * q.Z * v.Y + | ||
210 | q.W * q.W * v.Y - | ||
211 | 2f * q.X * q.W * v.Z - | ||
212 | q.X * q.X * v.Y; | ||
213 | |||
214 | c2.Z = | ||
215 | 2f * q.X * q.Z * v.X + | ||
216 | 2f * q.Y * q.Z * v.Y + | ||
217 | q.Z * q.Z * v.Z - | ||
218 | 2f * q.W * q.Y * v.X - | ||
219 | q.Y * q.Y * v.Z + | ||
220 | 2f * q.W * q.X * v.Y - | ||
221 | q.X * q.X * v.Z + | ||
222 | q.W * q.W * v.Z; | ||
223 | |||
224 | return c2; | ||
225 | } | ||
226 | } | ||
227 | |||
228 | public struct UVCoord | ||
229 | { | ||
230 | public float U; | ||
231 | public float V; | ||
232 | |||
233 | |||
234 | public UVCoord(float u, float v) | ||
235 | { | ||
236 | this.U = u; | ||
237 | this.V = v; | ||
238 | } | ||
239 | } | ||
240 | |||
241 | public struct Face | ||
242 | { | ||
243 | public int primFace; | ||
244 | |||
245 | // vertices | ||
246 | public int v1; | ||
247 | public int v2; | ||
248 | public int v3; | ||
249 | |||
250 | //normals | ||
251 | public int n1; | ||
252 | public int n2; | ||
253 | public int n3; | ||
254 | |||
255 | // uvs | ||
256 | public int uv1; | ||
257 | public int uv2; | ||
258 | public int uv3; | ||
259 | |||
260 | public Face(int v1, int v2, int v3) | ||
261 | { | ||
262 | primFace = 0; | ||
263 | |||
264 | this.v1 = v1; | ||
265 | this.v2 = v2; | ||
266 | this.v3 = v3; | ||
267 | |||
268 | this.n1 = 0; | ||
269 | this.n2 = 0; | ||
270 | this.n3 = 0; | ||
271 | |||
272 | this.uv1 = 0; | ||
273 | this.uv2 = 0; | ||
274 | this.uv3 = 0; | ||
275 | |||
276 | } | ||
277 | |||
278 | public Face(int v1, int v2, int v3, int n1, int n2, int n3) | ||
279 | { | ||
280 | primFace = 0; | ||
281 | |||
282 | this.v1 = v1; | ||
283 | this.v2 = v2; | ||
284 | this.v3 = v3; | ||
285 | |||
286 | this.n1 = n1; | ||
287 | this.n2 = n2; | ||
288 | this.n3 = n3; | ||
289 | |||
290 | this.uv1 = 0; | ||
291 | this.uv2 = 0; | ||
292 | this.uv3 = 0; | ||
293 | } | ||
294 | |||
295 | public Coord SurfaceNormal(List<Coord> coordList) | ||
296 | { | ||
297 | Coord c1 = coordList[this.v1]; | ||
298 | Coord c2 = coordList[this.v2]; | ||
299 | Coord c3 = coordList[this.v3]; | ||
300 | |||
301 | Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z); | ||
302 | Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z); | ||
303 | |||
304 | return Coord.Cross(edge1, edge2).Normalize(); | ||
305 | } | ||
306 | } | ||
307 | |||
308 | public struct ViewerFace | ||
309 | { | ||
310 | public int primFaceNumber; | ||
311 | |||
312 | public Coord v1; | ||
313 | public Coord v2; | ||
314 | public Coord v3; | ||
315 | |||
316 | public int coordIndex1; | ||
317 | public int coordIndex2; | ||
318 | public int coordIndex3; | ||
319 | |||
320 | public Coord n1; | ||
321 | public Coord n2; | ||
322 | public Coord n3; | ||
323 | |||
324 | public UVCoord uv1; | ||
325 | public UVCoord uv2; | ||
326 | public UVCoord uv3; | ||
327 | |||
328 | public ViewerFace(int primFaceNumber) | ||
329 | { | ||
330 | this.primFaceNumber = primFaceNumber; | ||
331 | |||
332 | this.v1 = new Coord(); | ||
333 | this.v2 = new Coord(); | ||
334 | this.v3 = new Coord(); | ||
335 | |||
336 | this.coordIndex1 = this.coordIndex2 = this.coordIndex3 = -1; // -1 means not assigned yet | ||
337 | |||
338 | this.n1 = new Coord(); | ||
339 | this.n2 = new Coord(); | ||
340 | this.n3 = new Coord(); | ||
341 | |||
342 | this.uv1 = new UVCoord(); | ||
343 | this.uv2 = new UVCoord(); | ||
344 | this.uv3 = new UVCoord(); | ||
345 | } | ||
346 | |||
347 | public void Scale(float x, float y, float z) | ||
348 | { | ||
349 | this.v1.X *= x; | ||
350 | this.v1.Y *= y; | ||
351 | this.v1.Z *= z; | ||
352 | |||
353 | this.v2.X *= x; | ||
354 | this.v2.Y *= y; | ||
355 | this.v2.Z *= z; | ||
356 | |||
357 | this.v3.X *= x; | ||
358 | this.v3.Y *= y; | ||
359 | this.v3.Z *= z; | ||
360 | } | ||
361 | |||
362 | public void AddPos(float x, float y, float z) | ||
363 | { | ||
364 | this.v1.X += x; | ||
365 | this.v2.X += x; | ||
366 | this.v3.X += x; | ||
367 | |||
368 | this.v1.Y += y; | ||
369 | this.v2.Y += y; | ||
370 | this.v3.Y += y; | ||
371 | |||
372 | this.v1.Z += z; | ||
373 | this.v2.Z += z; | ||
374 | this.v3.Z += z; | ||
375 | } | ||
376 | |||
377 | public void AddRot(Quat q) | ||
378 | { | ||
379 | this.v1 *= q; | ||
380 | this.v2 *= q; | ||
381 | this.v3 *= q; | ||
382 | |||
383 | this.n1 *= q; | ||
384 | this.n2 *= q; | ||
385 | this.n3 *= q; | ||
386 | } | ||
387 | |||
388 | public void CalcSurfaceNormal() | ||
389 | { | ||
390 | |||
391 | Coord edge1 = new Coord(this.v2.X - this.v1.X, this.v2.Y - this.v1.Y, this.v2.Z - this.v1.Z); | ||
392 | Coord edge2 = new Coord(this.v3.X - this.v1.X, this.v3.Y - this.v1.Y, this.v3.Z - this.v1.Z); | ||
393 | |||
394 | this.n1 = this.n2 = this.n3 = Coord.Cross(edge1, edge2).Normalize(); | ||
395 | } | ||
396 | } | ||
397 | |||
398 | internal struct Angle | ||
399 | { | ||
400 | internal float angle; | ||
401 | internal float X; | ||
402 | internal float Y; | ||
403 | |||
404 | internal Angle(float angle, float x, float y) | ||
405 | { | ||
406 | this.angle = angle; | ||
407 | this.X = x; | ||
408 | this.Y = y; | ||
409 | } | ||
410 | } | ||
411 | |||
412 | internal class AngleList | ||
413 | { | ||
414 | private float iX, iY; // intersection point | ||
415 | |||
416 | private static Angle[] angles3 = | ||
417 | { | ||
418 | new Angle(0.0f, 1.0f, 0.0f), | ||
419 | new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f), | ||
420 | new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f), | ||
421 | new Angle(1.0f, 1.0f, 0.0f) | ||
422 | }; | ||
423 | |||
424 | private static Coord[] normals3 = | ||
425 | { | ||
426 | new Coord(0.25f, 0.4330127019f, 0.0f).Normalize(), | ||
427 | new Coord(-0.5f, 0.0f, 0.0f).Normalize(), | ||
428 | new Coord(0.25f, -0.4330127019f, 0.0f).Normalize(), | ||
429 | new Coord(0.25f, 0.4330127019f, 0.0f).Normalize() | ||
430 | }; | ||
431 | |||
432 | private static Angle[] angles4 = | ||
433 | { | ||
434 | new Angle(0.0f, 1.0f, 0.0f), | ||
435 | new Angle(0.25f, 0.0f, 1.0f), | ||
436 | new Angle(0.5f, -1.0f, 0.0f), | ||
437 | new Angle(0.75f, 0.0f, -1.0f), | ||
438 | new Angle(1.0f, 1.0f, 0.0f) | ||
439 | }; | ||
440 | |||
441 | private static Coord[] normals4 = | ||
442 | { | ||
443 | new Coord(0.5f, 0.5f, 0.0f).Normalize(), | ||
444 | new Coord(-0.5f, 0.5f, 0.0f).Normalize(), | ||
445 | new Coord(-0.5f, -0.5f, 0.0f).Normalize(), | ||
446 | new Coord(0.5f, -0.5f, 0.0f).Normalize(), | ||
447 | new Coord(0.5f, 0.5f, 0.0f).Normalize() | ||
448 | }; | ||
449 | |||
450 | private static Angle[] angles24 = | ||
451 | { | ||
452 | new Angle(0.0f, 1.0f, 0.0f), | ||
453 | new Angle(0.041666666666666664f, 0.96592582628906831f, 0.25881904510252074f), | ||
454 | new Angle(0.083333333333333329f, 0.86602540378443871f, 0.5f), | ||
455 | new Angle(0.125f, 0.70710678118654757f, 0.70710678118654746f), | ||
456 | new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f), | ||
457 | new Angle(0.20833333333333331f, 0.25881904510252096f, 0.9659258262890682f), | ||
458 | new Angle(0.25f, 0.0f, 1.0f), | ||
459 | new Angle(0.29166666666666663f, -0.25881904510252063f, 0.96592582628906831f), | ||
460 | new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f), | ||
461 | new Angle(0.375f, -0.70710678118654746f, 0.70710678118654757f), | ||
462 | new Angle(0.41666666666666663f, -0.86602540378443849f, 0.5f), | ||
463 | new Angle(0.45833333333333331f, -0.9659258262890682f, 0.25881904510252102f), | ||
464 | new Angle(0.5f, -1.0f, 0.0f), | ||
465 | new Angle(0.54166666666666663f, -0.96592582628906842f, -0.25881904510252035f), | ||
466 | new Angle(0.58333333333333326f, -0.86602540378443882f, -0.5f), | ||
467 | new Angle(0.62499999999999989f, -0.70710678118654791f, -0.70710678118654713f), | ||
468 | new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f), | ||
469 | new Angle(0.70833333333333326f, -0.25881904510252152f, -0.96592582628906809f), | ||
470 | new Angle(0.75f, 0.0f, -1.0f), | ||
471 | new Angle(0.79166666666666663f, 0.2588190451025203f, -0.96592582628906842f), | ||
472 | new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f), | ||
473 | new Angle(0.875f, 0.70710678118654735f, -0.70710678118654768f), | ||
474 | new Angle(0.91666666666666663f, 0.86602540378443837f, -0.5f), | ||
475 | new Angle(0.95833333333333326f, 0.96592582628906809f, -0.25881904510252157f), | ||
476 | new Angle(1.0f, 1.0f, 0.0f) | ||
477 | }; | ||
478 | |||
479 | private Angle interpolatePoints(float newPoint, Angle p1, Angle p2) | ||
480 | { | ||
481 | float m = (newPoint - p1.angle) / (p2.angle - p1.angle); | ||
482 | return new Angle(newPoint, p1.X + m * (p2.X - p1.X), p1.Y + m * (p2.Y - p1.Y)); | ||
483 | } | ||
484 | |||
485 | private void intersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) | ||
486 | { // ref: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/ | ||
487 | double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); | ||
488 | double uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3); | ||
489 | |||
490 | if (denom != 0.0) | ||
491 | { | ||
492 | double ua = uaNumerator / denom; | ||
493 | iX = (float)(x1 + ua * (x2 - x1)); | ||
494 | iY = (float)(y1 + ua * (y2 - y1)); | ||
495 | } | ||
496 | } | ||
497 | |||
498 | internal List<Angle> angles; | ||
499 | internal List<Coord> normals; | ||
500 | |||
501 | internal void makeAngles(int sides, float startAngle, float stopAngle) | ||
502 | { | ||
503 | angles = new List<Angle>(); | ||
504 | normals = new List<Coord>(); | ||
505 | |||
506 | double twoPi = System.Math.PI * 2.0; | ||
507 | float twoPiInv = 1.0f / (float)twoPi; | ||
508 | |||
509 | if (sides < 1) | ||
510 | throw new Exception("number of sides not greater than zero"); | ||
511 | if (stopAngle <= startAngle) | ||
512 | throw new Exception("stopAngle not greater than startAngle"); | ||
513 | |||
514 | if ((sides == 3 || sides == 4 || sides == 24)) | ||
515 | { | ||
516 | startAngle *= twoPiInv; | ||
517 | stopAngle *= twoPiInv; | ||
518 | |||
519 | Angle[] sourceAngles; | ||
520 | if (sides == 3) | ||
521 | sourceAngles = angles3; | ||
522 | else if (sides == 4) | ||
523 | sourceAngles = angles4; | ||
524 | else sourceAngles = angles24; | ||
525 | |||
526 | int startAngleIndex = (int)(startAngle * sides); | ||
527 | int endAngleIndex = sourceAngles.Length - 1; | ||
528 | if (stopAngle < 1.0f) | ||
529 | endAngleIndex = (int)(stopAngle * sides) + 1; | ||
530 | if (endAngleIndex == startAngleIndex) | ||
531 | endAngleIndex++; | ||
532 | |||
533 | for (int angleIndex = startAngleIndex; angleIndex < endAngleIndex + 1; angleIndex++) | ||
534 | { | ||
535 | angles.Add(sourceAngles[angleIndex]); | ||
536 | if (sides == 3) | ||
537 | normals.Add(normals3[angleIndex]); | ||
538 | else if (sides == 4) | ||
539 | normals.Add(normals4[angleIndex]); | ||
540 | } | ||
541 | |||
542 | if (startAngle > 0.0f) | ||
543 | angles[0] = interpolatePoints(startAngle, angles[0], angles[1]); | ||
544 | |||
545 | if (stopAngle < 1.0f) | ||
546 | { | ||
547 | int lastAngleIndex = angles.Count - 1; | ||
548 | angles[lastAngleIndex] = interpolatePoints(stopAngle, angles[lastAngleIndex - 1], angles[lastAngleIndex]); | ||
549 | } | ||
550 | } | ||
551 | else | ||
552 | { | ||
553 | double stepSize = twoPi / sides; | ||
554 | |||
555 | int startStep = (int)(startAngle / stepSize); | ||
556 | double angle = stepSize * startStep; | ||
557 | int step = startStep; | ||
558 | double stopAngleTest = stopAngle; | ||
559 | if (stopAngle < twoPi) | ||
560 | { | ||
561 | stopAngleTest = stepSize * ((int)(stopAngle / stepSize) + 1); | ||
562 | if (stopAngleTest < stopAngle) | ||
563 | stopAngleTest += stepSize; | ||
564 | if (stopAngleTest > twoPi) | ||
565 | stopAngleTest = twoPi; | ||
566 | } | ||
567 | |||
568 | while (angle <= stopAngleTest) | ||
569 | { | ||
570 | Angle newAngle; | ||
571 | newAngle.angle = (float)angle; | ||
572 | newAngle.X = (float)System.Math.Cos(angle); | ||
573 | newAngle.Y = (float)System.Math.Sin(angle); | ||
574 | angles.Add(newAngle); | ||
575 | step += 1; | ||
576 | angle = stepSize * step; | ||
577 | } | ||
578 | |||
579 | if (startAngle > angles[0].angle) | ||
580 | { | ||
581 | Angle newAngle; | ||
582 | intersection(angles[0].X, angles[0].Y, angles[1].X, angles[1].Y, 0.0f, 0.0f, (float)Math.Cos(startAngle), (float)Math.Sin(startAngle)); | ||
583 | newAngle.angle = startAngle; | ||
584 | newAngle.X = iX; | ||
585 | newAngle.Y = iY; | ||
586 | angles[0] = newAngle; | ||
587 | } | ||
588 | |||
589 | int index = angles.Count - 1; | ||
590 | if (stopAngle < angles[index].angle) | ||
591 | { | ||
592 | Angle newAngle; | ||
593 | intersection(angles[index - 1].X, angles[index - 1].Y, angles[index].X, angles[index].Y, 0.0f, 0.0f, (float)Math.Cos(stopAngle), (float)Math.Sin(stopAngle)); | ||
594 | newAngle.angle = stopAngle; | ||
595 | newAngle.X = iX; | ||
596 | newAngle.Y = iY; | ||
597 | angles[index] = newAngle; | ||
598 | } | ||
599 | } | ||
600 | } | ||
601 | } | ||
602 | |||
603 | /// <summary> | ||
604 | /// generates a profile for extrusion | ||
605 | /// </summary> | ||
606 | internal class Profile | ||
607 | { | ||
608 | private const float twoPi = 2.0f * (float)Math.PI; | ||
609 | |||
610 | internal string errorMessage = null; | ||
611 | |||
612 | internal List<Coord> coords; | ||
613 | internal List<Face> faces; | ||
614 | internal List<Coord> vertexNormals; | ||
615 | internal List<float> us; | ||
616 | internal List<UVCoord> faceUVs; | ||
617 | internal List<int> faceNumbers; | ||
618 | |||
619 | // use these for making individual meshes for each prim face | ||
620 | internal List<int> outerCoordIndices = null; | ||
621 | internal List<int> hollowCoordIndices = null; | ||
622 | internal List<int> cut1CoordIndices = null; | ||
623 | internal List<int> cut2CoordIndices = null; | ||
624 | |||
625 | internal Coord faceNormal = new Coord(0.0f, 0.0f, 1.0f); | ||
626 | internal Coord cutNormal1 = new Coord(); | ||
627 | internal Coord cutNormal2 = new Coord(); | ||
628 | |||
629 | internal int numOuterVerts = 0; | ||
630 | internal int numHollowVerts = 0; | ||
631 | |||
632 | internal int outerFaceNumber = -1; | ||
633 | internal int hollowFaceNumber = -1; | ||
634 | |||
635 | internal bool calcVertexNormals = false; | ||
636 | internal int bottomFaceNumber = 0; | ||
637 | internal int numPrimFaces = 0; | ||
638 | |||
639 | internal Profile() | ||
640 | { | ||
641 | this.coords = new List<Coord>(); | ||
642 | this.faces = new List<Face>(); | ||
643 | this.vertexNormals = new List<Coord>(); | ||
644 | this.us = new List<float>(); | ||
645 | this.faceUVs = new List<UVCoord>(); | ||
646 | this.faceNumbers = new List<int>(); | ||
647 | } | ||
648 | |||
649 | internal Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides, bool createFaces, bool calcVertexNormals) | ||
650 | { | ||
651 | this.calcVertexNormals = calcVertexNormals; | ||
652 | this.coords = new List<Coord>(); | ||
653 | this.faces = new List<Face>(); | ||
654 | this.vertexNormals = new List<Coord>(); | ||
655 | this.us = new List<float>(); | ||
656 | this.faceUVs = new List<UVCoord>(); | ||
657 | this.faceNumbers = new List<int>(); | ||
658 | |||
659 | Coord center = new Coord(0.0f, 0.0f, 0.0f); | ||
660 | //bool hasCenter = false; | ||
661 | |||
662 | List<Coord> hollowCoords = new List<Coord>(); | ||
663 | List<Coord> hollowNormals = new List<Coord>(); | ||
664 | List<float> hollowUs = new List<float>(); | ||
665 | |||
666 | if (calcVertexNormals) | ||
667 | { | ||
668 | this.outerCoordIndices = new List<int>(); | ||
669 | this.hollowCoordIndices = new List<int>(); | ||
670 | this.cut1CoordIndices = new List<int>(); | ||
671 | this.cut2CoordIndices = new List<int>(); | ||
672 | } | ||
673 | |||
674 | bool hasHollow = (hollow > 0.0f); | ||
675 | |||
676 | bool hasProfileCut = (profileStart > 0.0f || profileEnd < 1.0f); | ||
677 | |||
678 | AngleList angles = new AngleList(); | ||
679 | AngleList hollowAngles = new AngleList(); | ||
680 | |||
681 | float xScale = 0.5f; | ||
682 | float yScale = 0.5f; | ||
683 | if (sides == 4) // corners of a square are sqrt(2) from center | ||
684 | { | ||
685 | xScale = 0.707f; | ||
686 | yScale = 0.707f; | ||
687 | } | ||
688 | |||
689 | float startAngle = profileStart * twoPi; | ||
690 | float stopAngle = profileEnd * twoPi; | ||
691 | |||
692 | try { angles.makeAngles(sides, startAngle, stopAngle); } | ||
693 | catch (Exception ex) | ||
694 | { | ||
695 | |||
696 | errorMessage = "makeAngles failed: Exception: " + ex.ToString() | ||
697 | + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString(); | ||
698 | |||
699 | return; | ||
700 | } | ||
701 | |||
702 | this.numOuterVerts = angles.angles.Count; | ||
703 | |||
704 | // flag to create as few triangles as possible for 3 or 4 side profile | ||
705 | bool simpleFace = (sides < 5 && !hasHollow && !hasProfileCut); | ||
706 | |||
707 | if (hasHollow) | ||
708 | { | ||
709 | if (sides == hollowSides) | ||
710 | hollowAngles = angles; | ||
711 | else | ||
712 | { | ||
713 | try { hollowAngles.makeAngles(hollowSides, startAngle, stopAngle); } | ||
714 | catch (Exception ex) | ||
715 | { | ||
716 | errorMessage = "makeAngles failed: Exception: " + ex.ToString() | ||
717 | + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString(); | ||
718 | |||
719 | return; | ||
720 | } | ||
721 | } | ||
722 | this.numHollowVerts = hollowAngles.angles.Count; | ||
723 | } | ||
724 | else if (!simpleFace) | ||
725 | { | ||
726 | this.coords.Add(center); | ||
727 | //hasCenter = true; | ||
728 | if (this.calcVertexNormals) | ||
729 | this.vertexNormals.Add(new Coord(0.0f, 0.0f, 1.0f)); | ||
730 | this.us.Add(0.0f); | ||
731 | } | ||
732 | |||
733 | float z = 0.0f; | ||
734 | |||
735 | Angle angle; | ||
736 | Coord newVert = new Coord(); | ||
737 | if (hasHollow && hollowSides != sides) | ||
738 | { | ||
739 | int numHollowAngles = hollowAngles.angles.Count; | ||
740 | for (int i = 0; i < numHollowAngles; i++) | ||
741 | { | ||
742 | angle = hollowAngles.angles[i]; | ||
743 | newVert.X = hollow * xScale * angle.X; | ||
744 | newVert.Y = hollow * yScale * angle.Y; | ||
745 | newVert.Z = z; | ||
746 | |||
747 | hollowCoords.Add(newVert); | ||
748 | if (this.calcVertexNormals) | ||
749 | { | ||
750 | if (hollowSides < 5) | ||
751 | hollowNormals.Add(hollowAngles.normals[i].Invert()); | ||
752 | else | ||
753 | hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f)); | ||
754 | |||
755 | hollowUs.Add(angle.angle * hollow); | ||
756 | } | ||
757 | } | ||
758 | } | ||
759 | |||
760 | int index = 0; | ||
761 | int numAngles = angles.angles.Count; | ||
762 | |||
763 | for (int i = 0; i < numAngles; i++) | ||
764 | { | ||
765 | angle = angles.angles[i]; | ||
766 | newVert.X = angle.X * xScale; | ||
767 | newVert.Y = angle.Y * yScale; | ||
768 | newVert.Z = z; | ||
769 | this.coords.Add(newVert); | ||
770 | if (this.calcVertexNormals) | ||
771 | { | ||
772 | this.outerCoordIndices.Add(this.coords.Count - 1); | ||
773 | |||
774 | if (sides < 5) | ||
775 | { | ||
776 | this.vertexNormals.Add(angles.normals[i]); | ||
777 | float u = angle.angle; | ||
778 | this.us.Add(u); | ||
779 | } | ||
780 | else | ||
781 | { | ||
782 | this.vertexNormals.Add(new Coord(angle.X, angle.Y, 0.0f)); | ||
783 | this.us.Add(angle.angle); | ||
784 | } | ||
785 | } | ||
786 | |||
787 | if (hasHollow) | ||
788 | { | ||
789 | if (hollowSides == sides) | ||
790 | { | ||
791 | newVert.X *= hollow; | ||
792 | newVert.Y *= hollow; | ||
793 | newVert.Z = z; | ||
794 | hollowCoords.Add(newVert); | ||
795 | if (this.calcVertexNormals) | ||
796 | { | ||
797 | if (sides < 5) | ||
798 | { | ||
799 | hollowNormals.Add(angles.normals[i].Invert()); | ||
800 | } | ||
801 | |||
802 | else | ||
803 | hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f)); | ||
804 | |||
805 | hollowUs.Add(angle.angle * hollow); | ||
806 | } | ||
807 | } | ||
808 | } | ||
809 | else if (!simpleFace && createFaces && angle.angle > 0.0001f) | ||
810 | { | ||
811 | Face newFace = new Face(); | ||
812 | newFace.v1 = 0; | ||
813 | newFace.v2 = index; | ||
814 | newFace.v3 = index + 1; | ||
815 | |||
816 | this.faces.Add(newFace); | ||
817 | } | ||
818 | index += 1; | ||
819 | } | ||
820 | |||
821 | if (hasHollow) | ||
822 | { | ||
823 | hollowCoords.Reverse(); | ||
824 | if (this.calcVertexNormals) | ||
825 | { | ||
826 | hollowNormals.Reverse(); | ||
827 | hollowUs.Reverse(); | ||
828 | } | ||
829 | |||
830 | if (createFaces) | ||
831 | { | ||
832 | //int numOuterVerts = this.coords.Count; | ||
833 | //numOuterVerts = this.coords.Count; | ||
834 | //int numHollowVerts = hollowCoords.Count; | ||
835 | int numTotalVerts = this.numOuterVerts + this.numHollowVerts; | ||
836 | |||
837 | if (this.numOuterVerts == this.numHollowVerts) | ||
838 | { | ||
839 | Face newFace = new Face(); | ||
840 | |||
841 | for (int coordIndex = 0; coordIndex < this.numOuterVerts - 1; coordIndex++) | ||
842 | { | ||
843 | newFace.v1 = coordIndex; | ||
844 | newFace.v2 = coordIndex + 1; | ||
845 | newFace.v3 = numTotalVerts - coordIndex - 1; | ||
846 | this.faces.Add(newFace); | ||
847 | |||
848 | newFace.v1 = coordIndex + 1; | ||
849 | newFace.v2 = numTotalVerts - coordIndex - 2; | ||
850 | newFace.v3 = numTotalVerts - coordIndex - 1; | ||
851 | this.faces.Add(newFace); | ||
852 | } | ||
853 | } | ||
854 | else | ||
855 | { | ||
856 | if (this.numOuterVerts < this.numHollowVerts) | ||
857 | { | ||
858 | Face newFace = new Face(); | ||
859 | int j = 0; // j is the index for outer vertices | ||
860 | int maxJ = this.numOuterVerts - 1; | ||
861 | for (int i = 0; i < this.numHollowVerts; i++) // i is the index for inner vertices | ||
862 | { | ||
863 | if (j < maxJ) | ||
864 | if (angles.angles[j + 1].angle - hollowAngles.angles[i].angle < hollowAngles.angles[i].angle - angles.angles[j].angle + 0.000001f) | ||
865 | { | ||
866 | newFace.v1 = numTotalVerts - i - 1; | ||
867 | newFace.v2 = j; | ||
868 | newFace.v3 = j + 1; | ||
869 | |||
870 | this.faces.Add(newFace); | ||
871 | j += 1; | ||
872 | } | ||
873 | |||
874 | newFace.v1 = j; | ||
875 | newFace.v2 = numTotalVerts - i - 2; | ||
876 | newFace.v3 = numTotalVerts - i - 1; | ||
877 | |||
878 | this.faces.Add(newFace); | ||
879 | } | ||
880 | } | ||
881 | else // numHollowVerts < numOuterVerts | ||
882 | { | ||
883 | Face newFace = new Face(); | ||
884 | int j = 0; // j is the index for inner vertices | ||
885 | int maxJ = this.numHollowVerts - 1; | ||
886 | for (int i = 0; i < this.numOuterVerts; i++) | ||
887 | { | ||
888 | if (j < maxJ) | ||
889 | if (hollowAngles.angles[j + 1].angle - angles.angles[i].angle < angles.angles[i].angle - hollowAngles.angles[j].angle + 0.000001f) | ||
890 | { | ||
891 | newFace.v1 = i; | ||
892 | newFace.v2 = numTotalVerts - j - 2; | ||
893 | newFace.v3 = numTotalVerts - j - 1; | ||
894 | |||
895 | this.faces.Add(newFace); | ||
896 | j += 1; | ||
897 | } | ||
898 | |||
899 | newFace.v1 = numTotalVerts - j - 1; | ||
900 | newFace.v2 = i; | ||
901 | newFace.v3 = i + 1; | ||
902 | |||
903 | this.faces.Add(newFace); | ||
904 | } | ||
905 | } | ||
906 | } | ||
907 | } | ||
908 | |||
909 | if (calcVertexNormals) | ||
910 | { | ||
911 | foreach (Coord hc in hollowCoords) | ||
912 | { | ||
913 | this.coords.Add(hc); | ||
914 | hollowCoordIndices.Add(this.coords.Count - 1); | ||
915 | } | ||
916 | } | ||
917 | else | ||
918 | this.coords.AddRange(hollowCoords); | ||
919 | |||
920 | if (this.calcVertexNormals) | ||
921 | { | ||
922 | this.vertexNormals.AddRange(hollowNormals); | ||
923 | this.us.AddRange(hollowUs); | ||
924 | |||
925 | } | ||
926 | } | ||
927 | |||
928 | if (simpleFace && createFaces) | ||
929 | { | ||
930 | if (sides == 3) | ||
931 | this.faces.Add(new Face(0, 1, 2)); | ||
932 | else if (sides == 4) | ||
933 | { | ||
934 | this.faces.Add(new Face(0, 1, 2)); | ||
935 | this.faces.Add(new Face(0, 2, 3)); | ||
936 | } | ||
937 | } | ||
938 | |||
939 | if (calcVertexNormals && hasProfileCut) | ||
940 | { | ||
941 | int lastOuterVertIndex = this.numOuterVerts - 1; | ||
942 | |||
943 | if (hasHollow) | ||
944 | { | ||
945 | this.cut1CoordIndices.Add(0); | ||
946 | this.cut1CoordIndices.Add(this.coords.Count - 1); | ||
947 | |||
948 | this.cut2CoordIndices.Add(lastOuterVertIndex + 1); | ||
949 | this.cut2CoordIndices.Add(lastOuterVertIndex); | ||
950 | |||
951 | this.cutNormal1.X = this.coords[0].Y - this.coords[this.coords.Count - 1].Y; | ||
952 | this.cutNormal1.Y = -(this.coords[0].X - this.coords[this.coords.Count - 1].X); | ||
953 | |||
954 | this.cutNormal2.X = this.coords[lastOuterVertIndex + 1].Y - this.coords[lastOuterVertIndex].Y; | ||
955 | this.cutNormal2.Y = -(this.coords[lastOuterVertIndex + 1].X - this.coords[lastOuterVertIndex].X); | ||
956 | } | ||
957 | |||
958 | else | ||
959 | { | ||
960 | this.cut1CoordIndices.Add(0); | ||
961 | this.cut1CoordIndices.Add(1); | ||
962 | |||
963 | this.cut2CoordIndices.Add(lastOuterVertIndex); | ||
964 | this.cut2CoordIndices.Add(0); | ||
965 | |||
966 | this.cutNormal1.X = this.vertexNormals[1].Y; | ||
967 | this.cutNormal1.Y = -this.vertexNormals[1].X; | ||
968 | |||
969 | this.cutNormal2.X = -this.vertexNormals[this.vertexNormals.Count - 2].Y; | ||
970 | this.cutNormal2.Y = this.vertexNormals[this.vertexNormals.Count - 2].X; | ||
971 | |||
972 | } | ||
973 | this.cutNormal1.Normalize(); | ||
974 | this.cutNormal2.Normalize(); | ||
975 | } | ||
976 | |||
977 | this.MakeFaceUVs(); | ||
978 | |||
979 | hollowCoords = null; | ||
980 | hollowNormals = null; | ||
981 | hollowUs = null; | ||
982 | |||
983 | if (calcVertexNormals) | ||
984 | { // calculate prim face numbers | ||
985 | |||
986 | // face number order is top, outer, hollow, bottom, start cut, end cut | ||
987 | // I know it's ugly but so is the whole concept of prim face numbers | ||
988 | |||
989 | int faceNum = 1; // start with outer faces | ||
990 | this.outerFaceNumber = faceNum; | ||
991 | |||
992 | int startVert = hasProfileCut && !hasHollow ? 1 : 0; | ||
993 | if (startVert > 0) | ||
994 | this.faceNumbers.Add(-1); | ||
995 | for (int i = 0; i < this.numOuterVerts - 1; i++) | ||
996 | //this.faceNumbers.Add(sides < 5 ? faceNum++ : faceNum); | ||
997 | this.faceNumbers.Add(sides < 5 && i < sides ? faceNum++ : faceNum); | ||
998 | |||
999 | //if (!hasHollow && !hasProfileCut) | ||
1000 | // this.bottomFaceNumber = faceNum++; | ||
1001 | |||
1002 | this.faceNumbers.Add(hasProfileCut ? -1 : faceNum++); | ||
1003 | |||
1004 | if (sides > 4 && (hasHollow || hasProfileCut)) | ||
1005 | faceNum++; | ||
1006 | |||
1007 | if (sides < 5 && (hasHollow || hasProfileCut) && this.numOuterVerts < sides) | ||
1008 | faceNum++; | ||
1009 | |||
1010 | if (hasHollow) | ||
1011 | { | ||
1012 | for (int i = 0; i < this.numHollowVerts; i++) | ||
1013 | this.faceNumbers.Add(faceNum); | ||
1014 | |||
1015 | this.hollowFaceNumber = faceNum++; | ||
1016 | } | ||
1017 | //if (hasProfileCut || hasHollow) | ||
1018 | // this.bottomFaceNumber = faceNum++; | ||
1019 | this.bottomFaceNumber = faceNum++; | ||
1020 | |||
1021 | if (hasHollow && hasProfileCut) | ||
1022 | this.faceNumbers.Add(faceNum++); | ||
1023 | |||
1024 | for (int i = 0; i < this.faceNumbers.Count; i++) | ||
1025 | if (this.faceNumbers[i] == -1) | ||
1026 | this.faceNumbers[i] = faceNum++; | ||
1027 | |||
1028 | this.numPrimFaces = faceNum; | ||
1029 | } | ||
1030 | |||
1031 | } | ||
1032 | |||
1033 | internal void MakeFaceUVs() | ||
1034 | { | ||
1035 | this.faceUVs = new List<UVCoord>(); | ||
1036 | foreach (Coord c in this.coords) | ||
1037 | this.faceUVs.Add(new UVCoord(0.5f + c.X, 0.5f - c.Y)); | ||
1038 | } | ||
1039 | |||
1040 | internal Profile Copy() | ||
1041 | { | ||
1042 | return this.Copy(true); | ||
1043 | } | ||
1044 | |||
1045 | internal Profile Copy(bool needFaces) | ||
1046 | { | ||
1047 | Profile copy = new Profile(); | ||
1048 | |||
1049 | copy.coords.AddRange(this.coords); | ||
1050 | copy.faceUVs.AddRange(this.faceUVs); | ||
1051 | |||
1052 | if (needFaces) | ||
1053 | copy.faces.AddRange(this.faces); | ||
1054 | if ((copy.calcVertexNormals = this.calcVertexNormals) == true) | ||
1055 | { | ||
1056 | copy.vertexNormals.AddRange(this.vertexNormals); | ||
1057 | copy.faceNormal = this.faceNormal; | ||
1058 | copy.cutNormal1 = this.cutNormal1; | ||
1059 | copy.cutNormal2 = this.cutNormal2; | ||
1060 | copy.us.AddRange(this.us); | ||
1061 | copy.faceNumbers.AddRange(this.faceNumbers); | ||
1062 | |||
1063 | copy.cut1CoordIndices = new List<int>(this.cut1CoordIndices); | ||
1064 | copy.cut2CoordIndices = new List<int>(this.cut2CoordIndices); | ||
1065 | copy.hollowCoordIndices = new List<int>(this.hollowCoordIndices); | ||
1066 | copy.outerCoordIndices = new List<int>(this.outerCoordIndices); | ||
1067 | } | ||
1068 | copy.numOuterVerts = this.numOuterVerts; | ||
1069 | copy.numHollowVerts = this.numHollowVerts; | ||
1070 | |||
1071 | return copy; | ||
1072 | } | ||
1073 | |||
1074 | internal void AddPos(Coord v) | ||
1075 | { | ||
1076 | this.AddPos(v.X, v.Y, v.Z); | ||
1077 | } | ||
1078 | |||
1079 | internal void AddPos(float x, float y, float z) | ||
1080 | { | ||
1081 | int i; | ||
1082 | int numVerts = this.coords.Count; | ||
1083 | Coord vert; | ||
1084 | |||
1085 | for (i = 0; i < numVerts; i++) | ||
1086 | { | ||
1087 | vert = this.coords[i]; | ||
1088 | vert.X += x; | ||
1089 | vert.Y += y; | ||
1090 | vert.Z += z; | ||
1091 | this.coords[i] = vert; | ||
1092 | } | ||
1093 | } | ||
1094 | |||
1095 | internal void AddRot(Quat q) | ||
1096 | { | ||
1097 | int i; | ||
1098 | int numVerts = this.coords.Count; | ||
1099 | |||
1100 | for (i = 0; i < numVerts; i++) | ||
1101 | this.coords[i] *= q; | ||
1102 | |||
1103 | if (this.calcVertexNormals) | ||
1104 | { | ||
1105 | int numNormals = this.vertexNormals.Count; | ||
1106 | for (i = 0; i < numNormals; i++) | ||
1107 | this.vertexNormals[i] *= q; | ||
1108 | |||
1109 | this.faceNormal *= q; | ||
1110 | this.cutNormal1 *= q; | ||
1111 | this.cutNormal2 *= q; | ||
1112 | |||
1113 | } | ||
1114 | } | ||
1115 | |||
1116 | internal void Scale(float x, float y) | ||
1117 | { | ||
1118 | int i; | ||
1119 | int numVerts = this.coords.Count; | ||
1120 | Coord vert; | ||
1121 | |||
1122 | for (i = 0; i < numVerts; i++) | ||
1123 | { | ||
1124 | vert = this.coords[i]; | ||
1125 | vert.X *= x; | ||
1126 | vert.Y *= y; | ||
1127 | this.coords[i] = vert; | ||
1128 | } | ||
1129 | } | ||
1130 | |||
1131 | /// <summary> | ||
1132 | /// Changes order of the vertex indices and negates the center vertex normal. Does not alter vertex normals of radial vertices | ||
1133 | /// </summary> | ||
1134 | internal void FlipNormals() | ||
1135 | { | ||
1136 | int i; | ||
1137 | int numFaces = this.faces.Count; | ||
1138 | Face tmpFace; | ||
1139 | int tmp; | ||
1140 | |||
1141 | for (i = 0; i < numFaces; i++) | ||
1142 | { | ||
1143 | tmpFace = this.faces[i]; | ||
1144 | tmp = tmpFace.v3; | ||
1145 | tmpFace.v3 = tmpFace.v1; | ||
1146 | tmpFace.v1 = tmp; | ||
1147 | this.faces[i] = tmpFace; | ||
1148 | } | ||
1149 | |||
1150 | if (this.calcVertexNormals) | ||
1151 | { | ||
1152 | int normalCount = this.vertexNormals.Count; | ||
1153 | if (normalCount > 0) | ||
1154 | { | ||
1155 | Coord n = this.vertexNormals[normalCount - 1]; | ||
1156 | n.Z = -n.Z; | ||
1157 | this.vertexNormals[normalCount - 1] = n; | ||
1158 | } | ||
1159 | } | ||
1160 | |||
1161 | this.faceNormal.X = -this.faceNormal.X; | ||
1162 | this.faceNormal.Y = -this.faceNormal.Y; | ||
1163 | this.faceNormal.Z = -this.faceNormal.Z; | ||
1164 | |||
1165 | int numfaceUVs = this.faceUVs.Count; | ||
1166 | for (i = 0; i < numfaceUVs; i++) | ||
1167 | { | ||
1168 | UVCoord uv = this.faceUVs[i]; | ||
1169 | uv.V = 1.0f - uv.V; | ||
1170 | this.faceUVs[i] = uv; | ||
1171 | } | ||
1172 | } | ||
1173 | |||
1174 | internal void AddValue2FaceVertexIndices(int num) | ||
1175 | { | ||
1176 | int numFaces = this.faces.Count; | ||
1177 | Face tmpFace; | ||
1178 | for (int i = 0; i < numFaces; i++) | ||
1179 | { | ||
1180 | tmpFace = this.faces[i]; | ||
1181 | tmpFace.v1 += num; | ||
1182 | tmpFace.v2 += num; | ||
1183 | tmpFace.v3 += num; | ||
1184 | |||
1185 | this.faces[i] = tmpFace; | ||
1186 | } | ||
1187 | } | ||
1188 | |||
1189 | internal void AddValue2FaceNormalIndices(int num) | ||
1190 | { | ||
1191 | if (this.calcVertexNormals) | ||
1192 | { | ||
1193 | int numFaces = this.faces.Count; | ||
1194 | Face tmpFace; | ||
1195 | for (int i = 0; i < numFaces; i++) | ||
1196 | { | ||
1197 | tmpFace = this.faces[i]; | ||
1198 | tmpFace.n1 += num; | ||
1199 | tmpFace.n2 += num; | ||
1200 | tmpFace.n3 += num; | ||
1201 | |||
1202 | this.faces[i] = tmpFace; | ||
1203 | } | ||
1204 | } | ||
1205 | } | ||
1206 | |||
1207 | internal void DumpRaw(String path, String name, String title) | ||
1208 | { | ||
1209 | if (path == null) | ||
1210 | return; | ||
1211 | String fileName = name + "_" + title + ".raw"; | ||
1212 | String completePath = System.IO.Path.Combine(path, fileName); | ||
1213 | StreamWriter sw = new StreamWriter(completePath); | ||
1214 | |||
1215 | for (int i = 0; i < this.faces.Count; i++) | ||
1216 | { | ||
1217 | string s = this.coords[this.faces[i].v1].ToString(); | ||
1218 | s += " " + this.coords[this.faces[i].v2].ToString(); | ||
1219 | s += " " + this.coords[this.faces[i].v3].ToString(); | ||
1220 | |||
1221 | sw.WriteLine(s); | ||
1222 | } | ||
1223 | |||
1224 | sw.Close(); | ||
1225 | } | ||
1226 | } | ||
1227 | |||
1228 | public struct PathNode | ||
1229 | { | ||
1230 | public Coord position; | ||
1231 | public Quat rotation; | ||
1232 | public float xScale; | ||
1233 | public float yScale; | ||
1234 | public float percentOfPath; | ||
1235 | } | ||
1236 | |||
1237 | public enum PathType { Linear = 0, Circular = 1, Flexible = 2 } | ||
1238 | |||
1239 | public class Path | ||
1240 | { | ||
1241 | public List<PathNode> pathNodes = new List<PathNode>(); | ||
1242 | |||
1243 | public float twistBegin = 0.0f; | ||
1244 | public float twistEnd = 0.0f; | ||
1245 | public float topShearX = 0.0f; | ||
1246 | public float topShearY = 0.0f; | ||
1247 | public float pathCutBegin = 0.0f; | ||
1248 | public float pathCutEnd = 1.0f; | ||
1249 | public float dimpleBegin = 0.0f; | ||
1250 | public float dimpleEnd = 1.0f; | ||
1251 | public float skew = 0.0f; | ||
1252 | public float holeSizeX = 1.0f; // called pathScaleX in pbs | ||
1253 | public float holeSizeY = 0.25f; | ||
1254 | public float taperX = 0.0f; | ||
1255 | public float taperY = 0.0f; | ||
1256 | public float radius = 0.0f; | ||
1257 | public float revolutions = 1.0f; | ||
1258 | public int stepsPerRevolution = 24; | ||
1259 | |||
1260 | private const float twoPi = 2.0f * (float)Math.PI; | ||
1261 | |||
1262 | public void Create(PathType pathType, int steps) | ||
1263 | { | ||
1264 | if (pathType == PathType.Linear || pathType == PathType.Flexible) | ||
1265 | { | ||
1266 | int step = 0; | ||
1267 | |||
1268 | float length = this.pathCutEnd - this.pathCutBegin; | ||
1269 | float twistTotal = twistEnd - twistBegin; | ||
1270 | float twistTotalAbs = Math.Abs(twistTotal); | ||
1271 | if (twistTotalAbs > 0.01f) | ||
1272 | steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number | ||
1273 | |||
1274 | float start = -0.5f; | ||
1275 | float stepSize = length / (float)steps; | ||
1276 | float percentOfPathMultiplier = stepSize; | ||
1277 | float xOffset = 0.0f; | ||
1278 | float yOffset = 0.0f; | ||
1279 | float zOffset = start; | ||
1280 | float xOffsetStepIncrement = this.topShearX / steps; | ||
1281 | float yOffsetStepIncrement = this.topShearY / steps; | ||
1282 | |||
1283 | float percentOfPath = this.pathCutBegin; | ||
1284 | zOffset += percentOfPath; | ||
1285 | |||
1286 | // sanity checks | ||
1287 | |||
1288 | bool done = false; | ||
1289 | |||
1290 | while (!done) | ||
1291 | { | ||
1292 | PathNode newNode = new PathNode(); | ||
1293 | |||
1294 | newNode.xScale = 1.0f; | ||
1295 | if (this.taperX == 0.0f) | ||
1296 | newNode.xScale = 1.0f; | ||
1297 | else if (this.taperX > 0.0f) | ||
1298 | newNode.xScale = 1.0f - percentOfPath * this.taperX; | ||
1299 | else newNode.xScale = 1.0f + (1.0f - percentOfPath) * this.taperX; | ||
1300 | |||
1301 | newNode.yScale = 1.0f; | ||
1302 | if (this.taperY == 0.0f) | ||
1303 | newNode.yScale = 1.0f; | ||
1304 | else if (this.taperY > 0.0f) | ||
1305 | newNode.yScale = 1.0f - percentOfPath * this.taperY; | ||
1306 | else newNode.yScale = 1.0f + (1.0f - percentOfPath) * this.taperY; | ||
1307 | |||
1308 | float twist = twistBegin + twistTotal * percentOfPath; | ||
1309 | |||
1310 | newNode.rotation = new Quat(new Coord(0.0f, 0.0f, 1.0f), twist); | ||
1311 | newNode.position = new Coord(xOffset, yOffset, zOffset); | ||
1312 | newNode.percentOfPath = percentOfPath; | ||
1313 | |||
1314 | pathNodes.Add(newNode); | ||
1315 | |||
1316 | if (step < steps) | ||
1317 | { | ||
1318 | step += 1; | ||
1319 | percentOfPath += percentOfPathMultiplier; | ||
1320 | xOffset += xOffsetStepIncrement; | ||
1321 | yOffset += yOffsetStepIncrement; | ||
1322 | zOffset += stepSize; | ||
1323 | if (percentOfPath > this.pathCutEnd) | ||
1324 | done = true; | ||
1325 | } | ||
1326 | else done = true; | ||
1327 | } | ||
1328 | } // end of linear path code | ||
1329 | |||
1330 | else // pathType == Circular | ||
1331 | { | ||
1332 | float twistTotal = twistEnd - twistBegin; | ||
1333 | |||
1334 | // if the profile has a lot of twist, add more layers otherwise the layers may overlap | ||
1335 | // and the resulting mesh may be quite inaccurate. This method is arbitrary and doesn't | ||
1336 | // accurately match the viewer | ||
1337 | float twistTotalAbs = Math.Abs(twistTotal); | ||
1338 | if (twistTotalAbs > 0.01f) | ||
1339 | { | ||
1340 | if (twistTotalAbs > Math.PI * 1.5f) | ||
1341 | steps *= 2; | ||
1342 | if (twistTotalAbs > Math.PI * 3.0f) | ||
1343 | steps *= 2; | ||
1344 | } | ||
1345 | |||
1346 | float yPathScale = this.holeSizeY * 0.5f; | ||
1347 | float pathLength = this.pathCutEnd - this.pathCutBegin; | ||
1348 | float totalSkew = this.skew * 2.0f * pathLength; | ||
1349 | float skewStart = this.pathCutBegin * 2.0f * this.skew - this.skew; | ||
1350 | float xOffsetTopShearXFactor = this.topShearX * (0.25f + 0.5f * (0.5f - this.holeSizeY)); | ||
1351 | float yShearCompensation = 1.0f + Math.Abs(this.topShearY) * 0.25f; | ||
1352 | |||
1353 | // It's not quite clear what pushY (Y top shear) does, but subtracting it from the start and end | ||
1354 | // angles appears to approximate it's effects on path cut. Likewise, adding it to the angle used | ||
1355 | // to calculate the sine for generating the path radius appears to approximate it's effects there | ||
1356 | // too, but there are some subtle differences in the radius which are noticeable as the prim size | ||
1357 | // increases and it may affect megaprims quite a bit. The effect of the Y top shear parameter on | ||
1358 | // the meshes generated with this technique appear nearly identical in shape to the same prims when | ||
1359 | // displayed by the viewer. | ||
1360 | |||
1361 | float startAngle = (twoPi * this.pathCutBegin * this.revolutions) - this.topShearY * 0.9f; | ||
1362 | float endAngle = (twoPi * this.pathCutEnd * this.revolutions) - this.topShearY * 0.9f; | ||
1363 | float stepSize = twoPi / this.stepsPerRevolution; | ||
1364 | |||
1365 | int step = (int)(startAngle / stepSize); | ||
1366 | float angle = startAngle; | ||
1367 | |||
1368 | bool done = false; | ||
1369 | while (!done) // loop through the length of the path and add the layers | ||
1370 | { | ||
1371 | PathNode newNode = new PathNode(); | ||
1372 | |||
1373 | float xProfileScale = (1.0f - Math.Abs(this.skew)) * this.holeSizeX; | ||
1374 | float yProfileScale = this.holeSizeY; | ||
1375 | |||
1376 | float percentOfPath = angle / (twoPi * this.revolutions); | ||
1377 | float percentOfAngles = (angle - startAngle) / (endAngle - startAngle); | ||
1378 | |||
1379 | if (this.taperX > 0.01f) | ||
1380 | xProfileScale *= 1.0f - percentOfPath * this.taperX; | ||
1381 | else if (this.taperX < -0.01f) | ||
1382 | xProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperX; | ||
1383 | |||
1384 | if (this.taperY > 0.01f) | ||
1385 | yProfileScale *= 1.0f - percentOfPath * this.taperY; | ||
1386 | else if (this.taperY < -0.01f) | ||
1387 | yProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperY; | ||
1388 | |||
1389 | newNode.xScale = xProfileScale; | ||
1390 | newNode.yScale = yProfileScale; | ||
1391 | |||
1392 | float radiusScale = 1.0f; | ||
1393 | if (this.radius > 0.001f) | ||
1394 | radiusScale = 1.0f - this.radius * percentOfPath; | ||
1395 | else if (this.radius < 0.001f) | ||
1396 | radiusScale = 1.0f + this.radius * (1.0f - percentOfPath); | ||
1397 | |||
1398 | float twist = twistBegin + twistTotal * percentOfPath; | ||
1399 | |||
1400 | float xOffset = 0.5f * (skewStart + totalSkew * percentOfAngles); | ||
1401 | xOffset += (float)Math.Sin(angle) * xOffsetTopShearXFactor; | ||
1402 | |||
1403 | float yOffset = yShearCompensation * (float)Math.Cos(angle) * (0.5f - yPathScale) * radiusScale; | ||
1404 | |||
1405 | float zOffset = (float)Math.Sin(angle + this.topShearY) * (0.5f - yPathScale) * radiusScale; | ||
1406 | |||
1407 | newNode.position = new Coord(xOffset, yOffset, zOffset); | ||
1408 | |||
1409 | // now orient the rotation of the profile layer relative to it's position on the path | ||
1410 | // adding taperY to the angle used to generate the quat appears to approximate the viewer | ||
1411 | |||
1412 | newNode.rotation = new Quat(new Coord(1.0f, 0.0f, 0.0f), angle + this.topShearY); | ||
1413 | |||
1414 | // next apply twist rotation to the profile layer | ||
1415 | if (twistTotal != 0.0f || twistBegin != 0.0f) | ||
1416 | newNode.rotation *= new Quat(new Coord(0.0f, 0.0f, 1.0f), twist); | ||
1417 | |||
1418 | newNode.percentOfPath = percentOfPath; | ||
1419 | |||
1420 | pathNodes.Add(newNode); | ||
1421 | |||
1422 | // calculate terms for next iteration | ||
1423 | // calculate the angle for the next iteration of the loop | ||
1424 | |||
1425 | if (angle >= endAngle - 0.01) | ||
1426 | done = true; | ||
1427 | else | ||
1428 | { | ||
1429 | step += 1; | ||
1430 | angle = stepSize * step; | ||
1431 | if (angle > endAngle) | ||
1432 | angle = endAngle; | ||
1433 | } | ||
1434 | } | ||
1435 | } | ||
1436 | } | ||
1437 | } | ||
1438 | |||
1439 | public class PrimMesh | ||
1440 | { | ||
1441 | public string errorMessage = ""; | ||
1442 | private const float twoPi = 2.0f * (float)Math.PI; | ||
1443 | |||
1444 | public List<Coord> coords; | ||
1445 | public List<Coord> normals; | ||
1446 | public List<Face> faces; | ||
1447 | |||
1448 | public List<ViewerFace> viewerFaces; | ||
1449 | |||
1450 | private int sides = 4; | ||
1451 | private int hollowSides = 4; | ||
1452 | private float profileStart = 0.0f; | ||
1453 | private float profileEnd = 1.0f; | ||
1454 | private float hollow = 0.0f; | ||
1455 | public int twistBegin = 0; | ||
1456 | public int twistEnd = 0; | ||
1457 | public float topShearX = 0.0f; | ||
1458 | public float topShearY = 0.0f; | ||
1459 | public float pathCutBegin = 0.0f; | ||
1460 | public float pathCutEnd = 1.0f; | ||
1461 | public float dimpleBegin = 0.0f; | ||
1462 | public float dimpleEnd = 1.0f; | ||
1463 | public float skew = 0.0f; | ||
1464 | public float holeSizeX = 1.0f; // called pathScaleX in pbs | ||
1465 | public float holeSizeY = 0.25f; | ||
1466 | public float taperX = 0.0f; | ||
1467 | public float taperY = 0.0f; | ||
1468 | public float radius = 0.0f; | ||
1469 | public float revolutions = 1.0f; | ||
1470 | public int stepsPerRevolution = 24; | ||
1471 | |||
1472 | private int profileOuterFaceNumber = -1; | ||
1473 | private int profileHollowFaceNumber = -1; | ||
1474 | |||
1475 | private bool hasProfileCut = false; | ||
1476 | private bool hasHollow = false; | ||
1477 | public bool calcVertexNormals = false; | ||
1478 | private bool normalsProcessed = false; | ||
1479 | public bool viewerMode = false; | ||
1480 | public bool sphereMode = false; | ||
1481 | |||
1482 | public int numPrimFaces = 0; | ||
1483 | |||
1484 | /// <summary> | ||
1485 | /// Human readable string representation of the parameters used to create a mesh. | ||
1486 | /// </summary> | ||
1487 | /// <returns></returns> | ||
1488 | public string ParamsToDisplayString() | ||
1489 | { | ||
1490 | string s = ""; | ||
1491 | s += "sides..................: " + this.sides.ToString(); | ||
1492 | s += "\nhollowSides..........: " + this.hollowSides.ToString(); | ||
1493 | s += "\nprofileStart.........: " + this.profileStart.ToString(); | ||
1494 | s += "\nprofileEnd...........: " + this.profileEnd.ToString(); | ||
1495 | s += "\nhollow...............: " + this.hollow.ToString(); | ||
1496 | s += "\ntwistBegin...........: " + this.twistBegin.ToString(); | ||
1497 | s += "\ntwistEnd.............: " + this.twistEnd.ToString(); | ||
1498 | s += "\ntopShearX............: " + this.topShearX.ToString(); | ||
1499 | s += "\ntopShearY............: " + this.topShearY.ToString(); | ||
1500 | s += "\npathCutBegin.........: " + this.pathCutBegin.ToString(); | ||
1501 | s += "\npathCutEnd...........: " + this.pathCutEnd.ToString(); | ||
1502 | s += "\ndimpleBegin..........: " + this.dimpleBegin.ToString(); | ||
1503 | s += "\ndimpleEnd............: " + this.dimpleEnd.ToString(); | ||
1504 | s += "\nskew.................: " + this.skew.ToString(); | ||
1505 | s += "\nholeSizeX............: " + this.holeSizeX.ToString(); | ||
1506 | s += "\nholeSizeY............: " + this.holeSizeY.ToString(); | ||
1507 | s += "\ntaperX...............: " + this.taperX.ToString(); | ||
1508 | s += "\ntaperY...............: " + this.taperY.ToString(); | ||
1509 | s += "\nradius...............: " + this.radius.ToString(); | ||
1510 | s += "\nrevolutions..........: " + this.revolutions.ToString(); | ||
1511 | s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString(); | ||
1512 | s += "\nsphereMode...........: " + this.sphereMode.ToString(); | ||
1513 | s += "\nhasProfileCut........: " + this.hasProfileCut.ToString(); | ||
1514 | s += "\nhasHollow............: " + this.hasHollow.ToString(); | ||
1515 | s += "\nviewerMode...........: " + this.viewerMode.ToString(); | ||
1516 | |||
1517 | return s; | ||
1518 | } | ||
1519 | |||
1520 | public int ProfileOuterFaceNumber | ||
1521 | { | ||
1522 | get { return profileOuterFaceNumber; } | ||
1523 | } | ||
1524 | |||
1525 | public int ProfileHollowFaceNumber | ||
1526 | { | ||
1527 | get { return profileHollowFaceNumber; } | ||
1528 | } | ||
1529 | |||
1530 | public bool HasProfileCut | ||
1531 | { | ||
1532 | get { return hasProfileCut; } | ||
1533 | } | ||
1534 | |||
1535 | public bool HasHollow | ||
1536 | { | ||
1537 | get { return hasHollow; } | ||
1538 | } | ||
1539 | |||
1540 | |||
1541 | /// <summary> | ||
1542 | /// Constructs a PrimMesh object and creates the profile for extrusion. | ||
1543 | /// </summary> | ||
1544 | /// <param name="sides"></param> | ||
1545 | /// <param name="profileStart"></param> | ||
1546 | /// <param name="profileEnd"></param> | ||
1547 | /// <param name="hollow"></param> | ||
1548 | /// <param name="hollowSides"></param> | ||
1549 | public PrimMesh(int sides, float profileStart, float profileEnd, float hollow, int hollowSides) | ||
1550 | { | ||
1551 | this.coords = new List<Coord>(); | ||
1552 | this.faces = new List<Face>(); | ||
1553 | |||
1554 | this.sides = sides; | ||
1555 | this.profileStart = profileStart; | ||
1556 | this.profileEnd = profileEnd; | ||
1557 | this.hollow = hollow; | ||
1558 | this.hollowSides = hollowSides; | ||
1559 | |||
1560 | if (sides < 3) | ||
1561 | this.sides = 3; | ||
1562 | if (hollowSides < 3) | ||
1563 | this.hollowSides = 3; | ||
1564 | if (profileStart < 0.0f) | ||
1565 | this.profileStart = 0.0f; | ||
1566 | if (profileEnd > 1.0f) | ||
1567 | this.profileEnd = 1.0f; | ||
1568 | if (profileEnd < 0.02f) | ||
1569 | this.profileEnd = 0.02f; | ||
1570 | if (profileStart >= profileEnd) | ||
1571 | this.profileStart = profileEnd - 0.02f; | ||
1572 | if (hollow > 0.99f) | ||
1573 | this.hollow = 0.99f; | ||
1574 | if (hollow < 0.0f) | ||
1575 | this.hollow = 0.0f; | ||
1576 | |||
1577 | //if (sphereMode) | ||
1578 | // this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f; | ||
1579 | //else | ||
1580 | // //this.hasProfileCut = (this.profileStart > 0.0f || this.profileEnd < 1.0f); | ||
1581 | // this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f; | ||
1582 | //this.hasHollow = (this.hollow > 0.001f); | ||
1583 | } | ||
1584 | |||
1585 | /// <summary> | ||
1586 | /// Extrudes a profile along a path. | ||
1587 | /// </summary> | ||
1588 | public void Extrude(PathType pathType) | ||
1589 | { | ||
1590 | bool needEndFaces = false; | ||
1591 | |||
1592 | this.coords = new List<Coord>(); | ||
1593 | this.faces = new List<Face>(); | ||
1594 | |||
1595 | if (this.viewerMode) | ||
1596 | { | ||
1597 | this.viewerFaces = new List<ViewerFace>(); | ||
1598 | this.calcVertexNormals = true; | ||
1599 | } | ||
1600 | |||
1601 | if (this.calcVertexNormals) | ||
1602 | this.normals = new List<Coord>(); | ||
1603 | |||
1604 | int steps = 1; | ||
1605 | |||
1606 | float length = this.pathCutEnd - this.pathCutBegin; | ||
1607 | normalsProcessed = false; | ||
1608 | |||
1609 | if (this.viewerMode && this.sides == 3) | ||
1610 | { | ||
1611 | // prisms don't taper well so add some vertical resolution | ||
1612 | // other prims may benefit from this but just do prisms for now | ||
1613 | if (Math.Abs(this.taperX) > 0.01 || Math.Abs(this.taperY) > 0.01) | ||
1614 | steps = (int)(steps * 4.5 * length); | ||
1615 | } | ||
1616 | |||
1617 | if (sphereMode) | ||
1618 | this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f; | ||
1619 | else | ||
1620 | //this.hasProfileCut = (this.profileStart > 0.0f || this.profileEnd < 1.0f); | ||
1621 | this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f; | ||
1622 | this.hasHollow = (this.hollow > 0.001f); | ||
1623 | |||
1624 | float twistBegin = this.twistBegin / 360.0f * twoPi; | ||
1625 | float twistEnd = this.twistEnd / 360.0f * twoPi; | ||
1626 | float twistTotal = twistEnd - twistBegin; | ||
1627 | float twistTotalAbs = Math.Abs(twistTotal); | ||
1628 | if (twistTotalAbs > 0.01f) | ||
1629 | steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number | ||
1630 | |||
1631 | float hollow = this.hollow; | ||
1632 | |||
1633 | // sanity checks | ||
1634 | float initialProfileRot = 0.0f; | ||
1635 | if (pathType == PathType.Circular) | ||
1636 | { | ||
1637 | if (this.sides == 3) | ||
1638 | { | ||
1639 | initialProfileRot = (float)Math.PI; | ||
1640 | if (this.hollowSides == 4) | ||
1641 | { | ||
1642 | if (hollow > 0.7f) | ||
1643 | hollow = 0.7f; | ||
1644 | hollow *= 0.707f; | ||
1645 | } | ||
1646 | else hollow *= 0.5f; | ||
1647 | } | ||
1648 | else if (this.sides == 4) | ||
1649 | { | ||
1650 | initialProfileRot = 0.25f * (float)Math.PI; | ||
1651 | if (this.hollowSides != 4) | ||
1652 | hollow *= 0.707f; | ||
1653 | } | ||
1654 | else if (this.sides > 4) | ||
1655 | { | ||
1656 | initialProfileRot = (float)Math.PI; | ||
1657 | if (this.hollowSides == 4) | ||
1658 | { | ||
1659 | if (hollow > 0.7f) | ||
1660 | hollow = 0.7f; | ||
1661 | hollow /= 0.7f; | ||
1662 | } | ||
1663 | } | ||
1664 | } | ||
1665 | else | ||
1666 | { | ||
1667 | if (this.sides == 3) | ||
1668 | { | ||
1669 | if (this.hollowSides == 4) | ||
1670 | { | ||
1671 | if (hollow > 0.7f) | ||
1672 | hollow = 0.7f; | ||
1673 | hollow *= 0.707f; | ||
1674 | } | ||
1675 | else hollow *= 0.5f; | ||
1676 | } | ||
1677 | else if (this.sides == 4) | ||
1678 | { | ||
1679 | initialProfileRot = 1.25f * (float)Math.PI; | ||
1680 | if (this.hollowSides != 4) | ||
1681 | hollow *= 0.707f; | ||
1682 | } | ||
1683 | else if (this.sides == 24 && this.hollowSides == 4) | ||
1684 | hollow *= 1.414f; | ||
1685 | } | ||
1686 | |||
1687 | Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides, true, calcVertexNormals); | ||
1688 | this.errorMessage = profile.errorMessage; | ||
1689 | |||
1690 | this.numPrimFaces = profile.numPrimFaces; | ||
1691 | |||
1692 | //profileOuterFaceNumber = profile.faceNumbers[0]; | ||
1693 | //if (!needEndFaces) | ||
1694 | // profileOuterFaceNumber--; | ||
1695 | //profileOuterFaceNumber = needEndFaces ? 1 : 0; | ||
1696 | |||
1697 | |||
1698 | //if (hasHollow) | ||
1699 | //{ | ||
1700 | // if (needEndFaces) | ||
1701 | // profileHollowFaceNumber = profile.faceNumbers[profile.numOuterVerts + 1]; | ||
1702 | // else | ||
1703 | // profileHollowFaceNumber = profile.faceNumbers[profile.numOuterVerts] - 1; | ||
1704 | //} | ||
1705 | |||
1706 | |||
1707 | profileOuterFaceNumber = profile.outerFaceNumber; | ||
1708 | if (!needEndFaces) | ||
1709 | profileOuterFaceNumber--; | ||
1710 | |||
1711 | if (hasHollow) | ||
1712 | { | ||
1713 | profileHollowFaceNumber = profile.hollowFaceNumber; | ||
1714 | if (!needEndFaces) | ||
1715 | profileHollowFaceNumber--; | ||
1716 | } | ||
1717 | |||
1718 | int cut1Vert = -1; | ||
1719 | int cut2Vert = -1; | ||
1720 | if (hasProfileCut) | ||
1721 | { | ||
1722 | cut1Vert = hasHollow ? profile.coords.Count - 1 : 0; | ||
1723 | cut2Vert = hasHollow ? profile.numOuterVerts - 1 : profile.numOuterVerts; | ||
1724 | } | ||
1725 | |||
1726 | if (initialProfileRot != 0.0f) | ||
1727 | { | ||
1728 | profile.AddRot(new Quat(new Coord(0.0f, 0.0f, 1.0f), initialProfileRot)); | ||
1729 | if (viewerMode) | ||
1730 | profile.MakeFaceUVs(); | ||
1731 | } | ||
1732 | |||
1733 | Coord lastCutNormal1 = new Coord(); | ||
1734 | Coord lastCutNormal2 = new Coord(); | ||
1735 | float lastV = 1.0f; | ||
1736 | |||
1737 | Path path = new Path(); | ||
1738 | path.twistBegin = twistBegin; | ||
1739 | path.twistEnd = twistEnd; | ||
1740 | path.topShearX = topShearX; | ||
1741 | path.topShearY = topShearY; | ||
1742 | path.pathCutBegin = pathCutBegin; | ||
1743 | path.pathCutEnd = pathCutEnd; | ||
1744 | path.dimpleBegin = dimpleBegin; | ||
1745 | path.dimpleEnd = dimpleEnd; | ||
1746 | path.skew = skew; | ||
1747 | path.holeSizeX = holeSizeX; | ||
1748 | path.holeSizeY = holeSizeY; | ||
1749 | path.taperX = taperX; | ||
1750 | path.taperY = taperY; | ||
1751 | path.radius = radius; | ||
1752 | path.revolutions = revolutions; | ||
1753 | path.stepsPerRevolution = stepsPerRevolution; | ||
1754 | |||
1755 | path.Create(pathType, steps); | ||
1756 | |||
1757 | |||
1758 | if (pathType == PathType.Circular) | ||
1759 | { | ||
1760 | needEndFaces = false; | ||
1761 | if (this.pathCutBegin != 0.0f || this.pathCutEnd != 1.0f) | ||
1762 | needEndFaces = true; | ||
1763 | else if (this.taperX != 0.0f || this.taperY != 0.0f) | ||
1764 | needEndFaces = true; | ||
1765 | else if (this.skew != 0.0f) | ||
1766 | needEndFaces = true; | ||
1767 | else if (twistTotal != 0.0f) | ||
1768 | needEndFaces = true; | ||
1769 | else if (this.radius != 0.0f) | ||
1770 | needEndFaces = true; | ||
1771 | } | ||
1772 | else needEndFaces = true; | ||
1773 | |||
1774 | for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++) | ||
1775 | { | ||
1776 | PathNode node = path.pathNodes[nodeIndex]; | ||
1777 | Profile newLayer = profile.Copy(); | ||
1778 | newLayer.Scale(node.xScale, node.yScale); | ||
1779 | |||
1780 | newLayer.AddRot(node.rotation); | ||
1781 | newLayer.AddPos(node.position); | ||
1782 | |||
1783 | if (needEndFaces && nodeIndex == 0) | ||
1784 | { | ||
1785 | newLayer.FlipNormals(); | ||
1786 | |||
1787 | // add the top faces to the viewerFaces list here | ||
1788 | if (this.viewerMode) | ||
1789 | { | ||
1790 | Coord faceNormal = newLayer.faceNormal; | ||
1791 | ViewerFace newViewerFace = new ViewerFace(profile.bottomFaceNumber); | ||
1792 | int numFaces = newLayer.faces.Count; | ||
1793 | List<Face> faces = newLayer.faces; | ||
1794 | |||
1795 | for (int i = 0; i < numFaces; i++) | ||
1796 | { | ||
1797 | Face face = faces[i]; | ||
1798 | newViewerFace.v1 = newLayer.coords[face.v1]; | ||
1799 | newViewerFace.v2 = newLayer.coords[face.v2]; | ||
1800 | newViewerFace.v3 = newLayer.coords[face.v3]; | ||
1801 | |||
1802 | newViewerFace.coordIndex1 = face.v1; | ||
1803 | newViewerFace.coordIndex2 = face.v2; | ||
1804 | newViewerFace.coordIndex3 = face.v3; | ||
1805 | |||
1806 | newViewerFace.n1 = faceNormal; | ||
1807 | newViewerFace.n2 = faceNormal; | ||
1808 | newViewerFace.n3 = faceNormal; | ||
1809 | |||
1810 | newViewerFace.uv1 = newLayer.faceUVs[face.v1]; | ||
1811 | newViewerFace.uv2 = newLayer.faceUVs[face.v2]; | ||
1812 | newViewerFace.uv3 = newLayer.faceUVs[face.v3]; | ||
1813 | |||
1814 | this.viewerFaces.Add(newViewerFace); | ||
1815 | } | ||
1816 | } | ||
1817 | } // if (nodeIndex == 0) | ||
1818 | |||
1819 | // append this layer | ||
1820 | |||
1821 | int coordsLen = this.coords.Count; | ||
1822 | newLayer.AddValue2FaceVertexIndices(coordsLen); | ||
1823 | |||
1824 | this.coords.AddRange(newLayer.coords); | ||
1825 | |||
1826 | if (this.calcVertexNormals) | ||
1827 | { | ||
1828 | newLayer.AddValue2FaceNormalIndices(this.normals.Count); | ||
1829 | this.normals.AddRange(newLayer.vertexNormals); | ||
1830 | } | ||
1831 | |||
1832 | if (node.percentOfPath < this.pathCutBegin + 0.01f || node.percentOfPath > this.pathCutEnd - 0.01f) | ||
1833 | this.faces.AddRange(newLayer.faces); | ||
1834 | |||
1835 | // fill faces between layers | ||
1836 | |||
1837 | int numVerts = newLayer.coords.Count; | ||
1838 | Face newFace = new Face(); | ||
1839 | |||
1840 | if (nodeIndex > 0) | ||
1841 | { | ||
1842 | int startVert = coordsLen + 1; | ||
1843 | int endVert = this.coords.Count; | ||
1844 | |||
1845 | if (sides < 5 || this.hasProfileCut || this.hasHollow) | ||
1846 | startVert--; | ||
1847 | |||
1848 | for (int i = startVert; i < endVert; i++) | ||
1849 | { | ||
1850 | int iNext = i + 1; | ||
1851 | if (i == endVert - 1) | ||
1852 | iNext = startVert; | ||
1853 | |||
1854 | int whichVert = i - startVert; | ||
1855 | |||
1856 | newFace.v1 = i; | ||
1857 | newFace.v2 = i - numVerts; | ||
1858 | newFace.v3 = iNext - numVerts; | ||
1859 | this.faces.Add(newFace); | ||
1860 | |||
1861 | newFace.v2 = iNext - numVerts; | ||
1862 | newFace.v3 = iNext; | ||
1863 | this.faces.Add(newFace); | ||
1864 | |||
1865 | if (this.viewerMode) | ||
1866 | { | ||
1867 | // add the side faces to the list of viewerFaces here | ||
1868 | |||
1869 | int primFaceNum = profile.faceNumbers[whichVert]; | ||
1870 | if (!needEndFaces) | ||
1871 | primFaceNum -= 1; | ||
1872 | |||
1873 | ViewerFace newViewerFace1 = new ViewerFace(primFaceNum); | ||
1874 | ViewerFace newViewerFace2 = new ViewerFace(primFaceNum); | ||
1875 | |||
1876 | float u1 = newLayer.us[whichVert]; | ||
1877 | float u2 = 1.0f; | ||
1878 | if (whichVert < newLayer.us.Count - 1) | ||
1879 | u2 = newLayer.us[whichVert + 1]; | ||
1880 | |||
1881 | if (whichVert == cut1Vert || whichVert == cut2Vert) | ||
1882 | { | ||
1883 | u1 = 0.0f; | ||
1884 | u2 = 1.0f; | ||
1885 | } | ||
1886 | else if (sides < 5) | ||
1887 | { | ||
1888 | if (whichVert < profile.numOuterVerts) | ||
1889 | { // boxes and prisms have one texture face per side of the prim, so the U values have to be scaled | ||
1890 | // to reflect the entire texture width | ||
1891 | u1 *= sides; | ||
1892 | u2 *= sides; | ||
1893 | u2 -= (int)u1; | ||
1894 | u1 -= (int)u1; | ||
1895 | if (u2 < 0.1f) | ||
1896 | u2 = 1.0f; | ||
1897 | //this.profileOuterFaceNumber = primFaceNum; | ||
1898 | } | ||
1899 | else if (whichVert > profile.coords.Count - profile.numHollowVerts - 1) | ||
1900 | { | ||
1901 | u1 *= 2.0f; | ||
1902 | u2 *= 2.0f; | ||
1903 | //this.profileHollowFaceNumber = primFaceNum; | ||
1904 | } | ||
1905 | } | ||
1906 | |||
1907 | newViewerFace1.uv1.U = u1; | ||
1908 | newViewerFace1.uv2.U = u1; | ||
1909 | newViewerFace1.uv3.U = u2; | ||
1910 | |||
1911 | newViewerFace1.uv1.V = 1.0f - node.percentOfPath; | ||
1912 | newViewerFace1.uv2.V = lastV; | ||
1913 | newViewerFace1.uv3.V = lastV; | ||
1914 | |||
1915 | newViewerFace2.uv1.U = u1; | ||
1916 | newViewerFace2.uv2.U = u2; | ||
1917 | newViewerFace2.uv3.U = u2; | ||
1918 | |||
1919 | newViewerFace2.uv1.V = 1.0f - node.percentOfPath; | ||
1920 | newViewerFace2.uv2.V = lastV; | ||
1921 | newViewerFace2.uv3.V = 1.0f - node.percentOfPath; | ||
1922 | |||
1923 | newViewerFace1.v1 = this.coords[i]; | ||
1924 | newViewerFace1.v2 = this.coords[i - numVerts]; | ||
1925 | newViewerFace1.v3 = this.coords[iNext - numVerts]; | ||
1926 | |||
1927 | newViewerFace2.v1 = this.coords[i]; | ||
1928 | newViewerFace2.v2 = this.coords[iNext - numVerts]; | ||
1929 | newViewerFace2.v3 = this.coords[iNext]; | ||
1930 | |||
1931 | newViewerFace1.coordIndex1 = i; | ||
1932 | newViewerFace1.coordIndex2 = i - numVerts; | ||
1933 | newViewerFace1.coordIndex3 = iNext - numVerts; | ||
1934 | |||
1935 | newViewerFace2.coordIndex1 = i; | ||
1936 | newViewerFace2.coordIndex2 = iNext - numVerts; | ||
1937 | newViewerFace2.coordIndex3 = iNext; | ||
1938 | |||
1939 | // profile cut faces | ||
1940 | if (whichVert == cut1Vert) | ||
1941 | { | ||
1942 | newViewerFace1.n1 = newLayer.cutNormal1; | ||
1943 | newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal1; | ||
1944 | |||
1945 | newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal1; | ||
1946 | newViewerFace2.n2 = lastCutNormal1; | ||
1947 | } | ||
1948 | else if (whichVert == cut2Vert) | ||
1949 | { | ||
1950 | newViewerFace1.n1 = newLayer.cutNormal2; | ||
1951 | newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal2; | ||
1952 | |||
1953 | newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal2; | ||
1954 | newViewerFace2.n2 = lastCutNormal2; | ||
1955 | } | ||
1956 | |||
1957 | else // outer and hollow faces | ||
1958 | { | ||
1959 | if ((sides < 5 && whichVert < newLayer.numOuterVerts) || (hollowSides < 5 && whichVert >= newLayer.numOuterVerts)) | ||
1960 | { // looks terrible when path is twisted... need vertex normals here | ||
1961 | newViewerFace1.CalcSurfaceNormal(); | ||
1962 | newViewerFace2.CalcSurfaceNormal(); | ||
1963 | } | ||
1964 | else | ||
1965 | { | ||
1966 | newViewerFace1.n1 = this.normals[i]; | ||
1967 | newViewerFace1.n2 = this.normals[i - numVerts]; | ||
1968 | newViewerFace1.n3 = this.normals[iNext - numVerts]; | ||
1969 | |||
1970 | newViewerFace2.n1 = this.normals[i]; | ||
1971 | newViewerFace2.n2 = this.normals[iNext - numVerts]; | ||
1972 | newViewerFace2.n3 = this.normals[iNext]; | ||
1973 | } | ||
1974 | } | ||
1975 | |||
1976 | this.viewerFaces.Add(newViewerFace1); | ||
1977 | this.viewerFaces.Add(newViewerFace2); | ||
1978 | |||
1979 | } | ||
1980 | } | ||
1981 | } | ||
1982 | |||
1983 | lastCutNormal1 = newLayer.cutNormal1; | ||
1984 | lastCutNormal2 = newLayer.cutNormal2; | ||
1985 | lastV = 1.0f - node.percentOfPath; | ||
1986 | |||
1987 | if (needEndFaces && nodeIndex == path.pathNodes.Count - 1 && viewerMode) | ||
1988 | { | ||
1989 | // add the top faces to the viewerFaces list here | ||
1990 | Coord faceNormal = newLayer.faceNormal; | ||
1991 | ViewerFace newViewerFace = new ViewerFace(); | ||
1992 | newViewerFace.primFaceNumber = 0; | ||
1993 | int numFaces = newLayer.faces.Count; | ||
1994 | List<Face> faces = newLayer.faces; | ||
1995 | |||
1996 | for (int i = 0; i < numFaces; i++) | ||
1997 | { | ||
1998 | Face face = faces[i]; | ||
1999 | newViewerFace.v1 = newLayer.coords[face.v1 - coordsLen]; | ||
2000 | newViewerFace.v2 = newLayer.coords[face.v2 - coordsLen]; | ||
2001 | newViewerFace.v3 = newLayer.coords[face.v3 - coordsLen]; | ||
2002 | |||
2003 | newViewerFace.coordIndex1 = face.v1 - coordsLen; | ||
2004 | newViewerFace.coordIndex2 = face.v2 - coordsLen; | ||
2005 | newViewerFace.coordIndex3 = face.v3 - coordsLen; | ||
2006 | |||
2007 | newViewerFace.n1 = faceNormal; | ||
2008 | newViewerFace.n2 = faceNormal; | ||
2009 | newViewerFace.n3 = faceNormal; | ||
2010 | |||
2011 | newViewerFace.uv1 = newLayer.faceUVs[face.v1 - coordsLen]; | ||
2012 | newViewerFace.uv2 = newLayer.faceUVs[face.v2 - coordsLen]; | ||
2013 | newViewerFace.uv3 = newLayer.faceUVs[face.v3 - coordsLen]; | ||
2014 | |||
2015 | this.viewerFaces.Add(newViewerFace); | ||
2016 | } | ||
2017 | } | ||
2018 | |||
2019 | |||
2020 | } // for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++) | ||
2021 | |||
2022 | } | ||
2023 | |||
2024 | |||
2025 | /// <summary> | ||
2026 | /// DEPRICATED - use Extrude(PathType.Linear) instead | ||
2027 | /// Extrudes a profile along a straight line path. Used for prim types box, cylinder, and prism. | ||
2028 | /// </summary> | ||
2029 | /// | ||
2030 | public void ExtrudeLinear() | ||
2031 | { | ||
2032 | this.Extrude(PathType.Linear); | ||
2033 | } | ||
2034 | |||
2035 | |||
2036 | /// <summary> | ||
2037 | /// DEPRICATED - use Extrude(PathType.Circular) instead | ||
2038 | /// Extrude a profile into a circular path prim mesh. Used for prim types torus, tube, and ring. | ||
2039 | /// </summary> | ||
2040 | /// | ||
2041 | public void ExtrudeCircular() | ||
2042 | { | ||
2043 | this.Extrude(PathType.Circular); | ||
2044 | } | ||
2045 | |||
2046 | |||
2047 | private Coord SurfaceNormal(Coord c1, Coord c2, Coord c3) | ||
2048 | { | ||
2049 | Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z); | ||
2050 | Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z); | ||
2051 | |||
2052 | Coord normal = Coord.Cross(edge1, edge2); | ||
2053 | |||
2054 | normal.Normalize(); | ||
2055 | |||
2056 | return normal; | ||
2057 | } | ||
2058 | |||
2059 | private Coord SurfaceNormal(Face face) | ||
2060 | { | ||
2061 | return SurfaceNormal(this.coords[face.v1], this.coords[face.v2], this.coords[face.v3]); | ||
2062 | } | ||
2063 | |||
2064 | /// <summary> | ||
2065 | /// Calculate the surface normal for a face in the list of faces | ||
2066 | /// </summary> | ||
2067 | /// <param name="faceIndex"></param> | ||
2068 | /// <returns></returns> | ||
2069 | public Coord SurfaceNormal(int faceIndex) | ||
2070 | { | ||
2071 | int numFaces = this.faces.Count; | ||
2072 | if (faceIndex < 0 || faceIndex >= numFaces) | ||
2073 | throw new Exception("faceIndex out of range"); | ||
2074 | |||
2075 | return SurfaceNormal(this.faces[faceIndex]); | ||
2076 | } | ||
2077 | |||
2078 | /// <summary> | ||
2079 | /// Duplicates a PrimMesh object. All object properties are copied by value, including lists. | ||
2080 | /// </summary> | ||
2081 | /// <returns></returns> | ||
2082 | public PrimMesh Copy() | ||
2083 | { | ||
2084 | PrimMesh copy = new PrimMesh(this.sides, this.profileStart, this.profileEnd, this.hollow, this.hollowSides); | ||
2085 | copy.twistBegin = this.twistBegin; | ||
2086 | copy.twistEnd = this.twistEnd; | ||
2087 | copy.topShearX = this.topShearX; | ||
2088 | copy.topShearY = this.topShearY; | ||
2089 | copy.pathCutBegin = this.pathCutBegin; | ||
2090 | copy.pathCutEnd = this.pathCutEnd; | ||
2091 | copy.dimpleBegin = this.dimpleBegin; | ||
2092 | copy.dimpleEnd = this.dimpleEnd; | ||
2093 | copy.skew = this.skew; | ||
2094 | copy.holeSizeX = this.holeSizeX; | ||
2095 | copy.holeSizeY = this.holeSizeY; | ||
2096 | copy.taperX = this.taperX; | ||
2097 | copy.taperY = this.taperY; | ||
2098 | copy.radius = this.radius; | ||
2099 | copy.revolutions = this.revolutions; | ||
2100 | copy.stepsPerRevolution = this.stepsPerRevolution; | ||
2101 | copy.calcVertexNormals = this.calcVertexNormals; | ||
2102 | copy.normalsProcessed = this.normalsProcessed; | ||
2103 | copy.viewerMode = this.viewerMode; | ||
2104 | copy.numPrimFaces = this.numPrimFaces; | ||
2105 | copy.errorMessage = this.errorMessage; | ||
2106 | |||
2107 | copy.coords = new List<Coord>(this.coords); | ||
2108 | copy.faces = new List<Face>(this.faces); | ||
2109 | copy.viewerFaces = new List<ViewerFace>(this.viewerFaces); | ||
2110 | copy.normals = new List<Coord>(this.normals); | ||
2111 | |||
2112 | return copy; | ||
2113 | } | ||
2114 | |||
2115 | /// <summary> | ||
2116 | /// Calculate surface normals for all of the faces in the list of faces in this mesh | ||
2117 | /// </summary> | ||
2118 | public void CalcNormals() | ||
2119 | { | ||
2120 | if (normalsProcessed) | ||
2121 | return; | ||
2122 | |||
2123 | normalsProcessed = true; | ||
2124 | |||
2125 | int numFaces = faces.Count; | ||
2126 | |||
2127 | if (!this.calcVertexNormals) | ||
2128 | this.normals = new List<Coord>(); | ||
2129 | |||
2130 | for (int i = 0; i < numFaces; i++) | ||
2131 | { | ||
2132 | Face face = faces[i]; | ||
2133 | |||
2134 | this.normals.Add(SurfaceNormal(i).Normalize()); | ||
2135 | |||
2136 | int normIndex = normals.Count - 1; | ||
2137 | face.n1 = normIndex; | ||
2138 | face.n2 = normIndex; | ||
2139 | face.n3 = normIndex; | ||
2140 | |||
2141 | this.faces[i] = face; | ||
2142 | } | ||
2143 | } | ||
2144 | |||
2145 | /// <summary> | ||
2146 | /// Adds a value to each XYZ vertex coordinate in the mesh | ||
2147 | /// </summary> | ||
2148 | /// <param name="x"></param> | ||
2149 | /// <param name="y"></param> | ||
2150 | /// <param name="z"></param> | ||
2151 | public void AddPos(float x, float y, float z) | ||
2152 | { | ||
2153 | int i; | ||
2154 | int numVerts = this.coords.Count; | ||
2155 | Coord vert; | ||
2156 | |||
2157 | for (i = 0; i < numVerts; i++) | ||
2158 | { | ||
2159 | vert = this.coords[i]; | ||
2160 | vert.X += x; | ||
2161 | vert.Y += y; | ||
2162 | vert.Z += z; | ||
2163 | this.coords[i] = vert; | ||
2164 | } | ||
2165 | |||
2166 | if (this.viewerFaces != null) | ||
2167 | { | ||
2168 | int numViewerFaces = this.viewerFaces.Count; | ||
2169 | |||
2170 | for (i = 0; i < numViewerFaces; i++) | ||
2171 | { | ||
2172 | ViewerFace v = this.viewerFaces[i]; | ||
2173 | v.AddPos(x, y, z); | ||
2174 | this.viewerFaces[i] = v; | ||
2175 | } | ||
2176 | } | ||
2177 | } | ||
2178 | |||
2179 | /// <summary> | ||
2180 | /// Rotates the mesh | ||
2181 | /// </summary> | ||
2182 | /// <param name="q"></param> | ||
2183 | public void AddRot(Quat q) | ||
2184 | { | ||
2185 | int i; | ||
2186 | int numVerts = this.coords.Count; | ||
2187 | |||
2188 | for (i = 0; i < numVerts; i++) | ||
2189 | this.coords[i] *= q; | ||
2190 | |||
2191 | if (this.normals != null) | ||
2192 | { | ||
2193 | int numNormals = this.normals.Count; | ||
2194 | for (i = 0; i < numNormals; i++) | ||
2195 | this.normals[i] *= q; | ||
2196 | } | ||
2197 | |||
2198 | if (this.viewerFaces != null) | ||
2199 | { | ||
2200 | int numViewerFaces = this.viewerFaces.Count; | ||
2201 | |||
2202 | for (i = 0; i < numViewerFaces; i++) | ||
2203 | { | ||
2204 | ViewerFace v = this.viewerFaces[i]; | ||
2205 | v.v1 *= q; | ||
2206 | v.v2 *= q; | ||
2207 | v.v3 *= q; | ||
2208 | |||
2209 | v.n1 *= q; | ||
2210 | v.n2 *= q; | ||
2211 | v.n3 *= q; | ||
2212 | this.viewerFaces[i] = v; | ||
2213 | } | ||
2214 | } | ||
2215 | } | ||
2216 | |||
2217 | #if VERTEX_INDEXER | ||
2218 | public VertexIndexer GetVertexIndexer() | ||
2219 | { | ||
2220 | if (this.viewerMode && this.viewerFaces.Count > 0) | ||
2221 | return new VertexIndexer(this); | ||
2222 | return null; | ||
2223 | } | ||
2224 | #endif | ||
2225 | |||
2226 | /// <summary> | ||
2227 | /// Scales the mesh | ||
2228 | /// </summary> | ||
2229 | /// <param name="x"></param> | ||
2230 | /// <param name="y"></param> | ||
2231 | /// <param name="z"></param> | ||
2232 | public void Scale(float x, float y, float z) | ||
2233 | { | ||
2234 | int i; | ||
2235 | int numVerts = this.coords.Count; | ||
2236 | //Coord vert; | ||
2237 | |||
2238 | Coord m = new Coord(x, y, z); | ||
2239 | for (i = 0; i < numVerts; i++) | ||
2240 | this.coords[i] *= m; | ||
2241 | |||
2242 | if (this.viewerFaces != null) | ||
2243 | { | ||
2244 | int numViewerFaces = this.viewerFaces.Count; | ||
2245 | for (i = 0; i < numViewerFaces; i++) | ||
2246 | { | ||
2247 | ViewerFace v = this.viewerFaces[i]; | ||
2248 | v.v1 *= m; | ||
2249 | v.v2 *= m; | ||
2250 | v.v3 *= m; | ||
2251 | this.viewerFaces[i] = v; | ||
2252 | } | ||
2253 | |||
2254 | } | ||
2255 | |||
2256 | } | ||
2257 | |||
2258 | /// <summary> | ||
2259 | /// Dumps the mesh to a Blender compatible "Raw" format file | ||
2260 | /// </summary> | ||
2261 | /// <param name="path"></param> | ||
2262 | /// <param name="name"></param> | ||
2263 | /// <param name="title"></param> | ||
2264 | public void DumpRaw(String path, String name, String title) | ||
2265 | { | ||
2266 | if (path == null) | ||
2267 | return; | ||
2268 | String fileName = name + "_" + title + ".raw"; | ||
2269 | String completePath = System.IO.Path.Combine(path, fileName); | ||
2270 | StreamWriter sw = new StreamWriter(completePath); | ||
2271 | |||
2272 | for (int i = 0; i < this.faces.Count; i++) | ||
2273 | { | ||
2274 | string s = this.coords[this.faces[i].v1].ToString(); | ||
2275 | s += " " + this.coords[this.faces[i].v2].ToString(); | ||
2276 | s += " " + this.coords[this.faces[i].v3].ToString(); | ||
2277 | |||
2278 | sw.WriteLine(s); | ||
2279 | } | ||
2280 | |||
2281 | sw.Close(); | ||
2282 | } | ||
2283 | } | ||
2284 | } | ||
diff --git a/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs b/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs new file mode 100644 index 0000000..b3d9cb6 --- /dev/null +++ b/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs | |||
@@ -0,0 +1,197 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors | ||
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 | // to build without references to System.Drawing, comment this out | ||
29 | #define SYSTEM_DRAWING | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | using System.Text; | ||
34 | |||
35 | #if SYSTEM_DRAWING | ||
36 | using System.Drawing; | ||
37 | using System.Drawing.Imaging; | ||
38 | |||
39 | namespace PrimMesher | ||
40 | { | ||
41 | public class SculptMap | ||
42 | { | ||
43 | public int width; | ||
44 | public int height; | ||
45 | public byte[] redBytes; | ||
46 | public byte[] greenBytes; | ||
47 | public byte[] blueBytes; | ||
48 | |||
49 | public SculptMap() | ||
50 | { | ||
51 | } | ||
52 | |||
53 | public SculptMap(Bitmap bm, int lod) | ||
54 | { | ||
55 | int bmW = bm.Width; | ||
56 | int bmH = bm.Height; | ||
57 | |||
58 | if (bmW == 0 || bmH == 0) | ||
59 | throw new Exception("SculptMap: bitmap has no data"); | ||
60 | |||
61 | int numLodPixels = lod * lod; // (32 * 2)^2 = 64^2 pixels for default sculpt map image | ||
62 | |||
63 | bool smallMap = bmW * bmH <= numLodPixels; | ||
64 | bool needsScaling = false; | ||
65 | |||
66 | width = bmW; | ||
67 | height = bmH; | ||
68 | while (width * height > numLodPixels * 4) | ||
69 | { | ||
70 | width >>= 1; | ||
71 | height >>= 1; | ||
72 | needsScaling = true; | ||
73 | } | ||
74 | |||
75 | try | ||
76 | { | ||
77 | if (needsScaling) | ||
78 | bm = ScaleImage(bm, width, height); | ||
79 | } | ||
80 | |||
81 | catch (Exception e) | ||
82 | { | ||
83 | throw new Exception("Exception in ScaleImage(): e: " + e.ToString()); | ||
84 | } | ||
85 | |||
86 | if (width * height > numLodPixels) | ||
87 | { | ||
88 | width >>= 1; | ||
89 | height >>= 1; | ||
90 | } | ||
91 | |||
92 | int numBytes = (width + 1) * (height + 1); | ||
93 | redBytes = new byte[numBytes]; | ||
94 | greenBytes = new byte[numBytes]; | ||
95 | blueBytes = new byte[numBytes]; | ||
96 | |||
97 | int byteNdx = 0; | ||
98 | |||
99 | try | ||
100 | { | ||
101 | for (int y = 0; y <= height; y++) | ||
102 | { | ||
103 | for (int x = 0; x <= width; x++) | ||
104 | { | ||
105 | Color c; | ||
106 | |||
107 | if (smallMap) | ||
108 | c = bm.GetPixel(x < width ? x : x - 1, | ||
109 | y < height ? y : y - 1); | ||
110 | else | ||
111 | c = bm.GetPixel(x < width ? x * 2 : x * 2 - 1, | ||
112 | y < height ? y * 2 : y * 2 - 1); | ||
113 | |||
114 | redBytes[byteNdx] = c.R; | ||
115 | greenBytes[byteNdx] = c.G; | ||
116 | blueBytes[byteNdx] = c.B; | ||
117 | |||
118 | ++byteNdx; | ||
119 | } | ||
120 | } | ||
121 | } | ||
122 | catch (Exception e) | ||
123 | { | ||
124 | throw new Exception("Caught exception processing byte arrays in SculptMap(): e: " + e.ToString()); | ||
125 | } | ||
126 | |||
127 | width++; | ||
128 | height++; | ||
129 | } | ||
130 | |||
131 | public List<List<Coord>> ToRows(bool mirror) | ||
132 | { | ||
133 | int numRows = height; | ||
134 | int numCols = width; | ||
135 | |||
136 | List<List<Coord>> rows = new List<List<Coord>>(numRows); | ||
137 | |||
138 | float pixScale = 1.0f / 255; | ||
139 | |||
140 | int rowNdx, colNdx; | ||
141 | int smNdx = 0; | ||
142 | |||
143 | |||
144 | for (rowNdx = 0; rowNdx < numRows; rowNdx++) | ||
145 | { | ||
146 | List<Coord> row = new List<Coord>(numCols); | ||
147 | for (colNdx = 0; colNdx < numCols; colNdx++) | ||
148 | { | ||
149 | |||
150 | if (mirror) | ||
151 | row.Add(new Coord(-((float)redBytes[smNdx] * pixScale - 0.5f), ((float)greenBytes[smNdx] * pixScale - 0.5f), (float)blueBytes[smNdx] * pixScale - 0.5f)); | ||
152 | else | ||
153 | row.Add(new Coord((float)redBytes[smNdx] * pixScale - 0.5f, (float)greenBytes[smNdx] * pixScale - 0.5f, (float)blueBytes[smNdx] * pixScale - 0.5f)); | ||
154 | |||
155 | ++smNdx; | ||
156 | } | ||
157 | rows.Add(row); | ||
158 | } | ||
159 | return rows; | ||
160 | } | ||
161 | |||
162 | private Bitmap ScaleImage(Bitmap srcImage, int destWidth, int destHeight) | ||
163 | { | ||
164 | |||
165 | Bitmap scaledImage = new Bitmap(destWidth, destHeight, PixelFormat.Format24bppRgb); | ||
166 | |||
167 | Color c; | ||
168 | float xscale = srcImage.Width / destWidth; | ||
169 | float yscale = srcImage.Height / destHeight; | ||
170 | |||
171 | float sy = 0.5f; | ||
172 | for (int y = 0; y < destHeight; y++) | ||
173 | { | ||
174 | float sx = 0.5f; | ||
175 | for (int x = 0; x < destWidth; x++) | ||
176 | { | ||
177 | try | ||
178 | { | ||
179 | c = srcImage.GetPixel((int)(sx), (int)(sy)); | ||
180 | scaledImage.SetPixel(x, y, Color.FromArgb(c.R, c.G, c.B)); | ||
181 | } | ||
182 | catch (IndexOutOfRangeException) | ||
183 | { | ||
184 | } | ||
185 | |||
186 | sx += xscale; | ||
187 | } | ||
188 | sy += yscale; | ||
189 | } | ||
190 | srcImage.Dispose(); | ||
191 | return scaledImage; | ||
192 | } | ||
193 | |||
194 | } | ||
195 | |||
196 | } | ||
197 | #endif | ||
diff --git a/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs b/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs new file mode 100644 index 0000000..4a7f3ad --- /dev/null +++ b/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs | |||
@@ -0,0 +1,646 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors | ||
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 | // to build without references to System.Drawing, comment this out | ||
29 | #define SYSTEM_DRAWING | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | using System.Text; | ||
34 | using System.IO; | ||
35 | |||
36 | #if SYSTEM_DRAWING | ||
37 | using System.Drawing; | ||
38 | using System.Drawing.Imaging; | ||
39 | #endif | ||
40 | |||
41 | namespace PrimMesher | ||
42 | { | ||
43 | |||
44 | public class SculptMesh | ||
45 | { | ||
46 | public List<Coord> coords; | ||
47 | public List<Face> faces; | ||
48 | |||
49 | public List<ViewerFace> viewerFaces; | ||
50 | public List<Coord> normals; | ||
51 | public List<UVCoord> uvs; | ||
52 | |||
53 | public enum SculptType { sphere = 1, torus = 2, plane = 3, cylinder = 4 }; | ||
54 | |||
55 | #if SYSTEM_DRAWING | ||
56 | |||
57 | public SculptMesh SculptMeshFromFile(string fileName, SculptType sculptType, int lod, bool viewerMode) | ||
58 | { | ||
59 | Bitmap bitmap = (Bitmap)Bitmap.FromFile(fileName); | ||
60 | SculptMesh sculptMesh = new SculptMesh(bitmap, sculptType, lod, viewerMode); | ||
61 | bitmap.Dispose(); | ||
62 | return sculptMesh; | ||
63 | } | ||
64 | |||
65 | |||
66 | public SculptMesh(string fileName, int sculptType, int lod, int viewerMode, int mirror, int invert) | ||
67 | { | ||
68 | Bitmap bitmap = (Bitmap)Bitmap.FromFile(fileName); | ||
69 | _SculptMesh(bitmap, (SculptType)sculptType, lod, viewerMode != 0, mirror != 0, invert != 0); | ||
70 | bitmap.Dispose(); | ||
71 | } | ||
72 | #endif | ||
73 | |||
74 | /// <summary> | ||
75 | /// ** Experimental ** May disappear from future versions ** not recommeneded for use in applications | ||
76 | /// Construct a sculpt mesh from a 2D array of floats | ||
77 | /// </summary> | ||
78 | /// <param name="zMap"></param> | ||
79 | /// <param name="xBegin"></param> | ||
80 | /// <param name="xEnd"></param> | ||
81 | /// <param name="yBegin"></param> | ||
82 | /// <param name="yEnd"></param> | ||
83 | /// <param name="viewerMode"></param> | ||
84 | public SculptMesh(float[,] zMap, float xBegin, float xEnd, float yBegin, float yEnd, bool viewerMode) | ||
85 | { | ||
86 | float xStep, yStep; | ||
87 | float uStep, vStep; | ||
88 | |||
89 | int numYElements = zMap.GetLength(0); | ||
90 | int numXElements = zMap.GetLength(1); | ||
91 | |||
92 | try | ||
93 | { | ||
94 | xStep = (xEnd - xBegin) / (float)(numXElements - 1); | ||
95 | yStep = (yEnd - yBegin) / (float)(numYElements - 1); | ||
96 | |||
97 | uStep = 1.0f / (numXElements - 1); | ||
98 | vStep = 1.0f / (numYElements - 1); | ||
99 | } | ||
100 | catch (DivideByZeroException) | ||
101 | { | ||
102 | return; | ||
103 | } | ||
104 | |||
105 | coords = new List<Coord>(); | ||
106 | faces = new List<Face>(); | ||
107 | normals = new List<Coord>(); | ||
108 | uvs = new List<UVCoord>(); | ||
109 | |||
110 | viewerFaces = new List<ViewerFace>(); | ||
111 | |||
112 | int p1, p2, p3, p4; | ||
113 | |||
114 | int x, y; | ||
115 | int xStart = 0, yStart = 0; | ||
116 | |||
117 | for (y = yStart; y < numYElements; y++) | ||
118 | { | ||
119 | int rowOffset = y * numXElements; | ||
120 | |||
121 | for (x = xStart; x < numXElements; x++) | ||
122 | { | ||
123 | /* | ||
124 | * p1-----p2 | ||
125 | * | \ f2 | | ||
126 | * | \ | | ||
127 | * | f1 \| | ||
128 | * p3-----p4 | ||
129 | */ | ||
130 | |||
131 | p4 = rowOffset + x; | ||
132 | p3 = p4 - 1; | ||
133 | |||
134 | p2 = p4 - numXElements; | ||
135 | p1 = p3 - numXElements; | ||
136 | |||
137 | Coord c = new Coord(xBegin + x * xStep, yBegin + y * yStep, zMap[y, x]); | ||
138 | this.coords.Add(c); | ||
139 | if (viewerMode) | ||
140 | { | ||
141 | this.normals.Add(new Coord()); | ||
142 | this.uvs.Add(new UVCoord(uStep * x, 1.0f - vStep * y)); | ||
143 | } | ||
144 | |||
145 | if (y > 0 && x > 0) | ||
146 | { | ||
147 | Face f1, f2; | ||
148 | |||
149 | if (viewerMode) | ||
150 | { | ||
151 | f1 = new Face(p1, p4, p3, p1, p4, p3); | ||
152 | f1.uv1 = p1; | ||
153 | f1.uv2 = p4; | ||
154 | f1.uv3 = p3; | ||
155 | |||
156 | f2 = new Face(p1, p2, p4, p1, p2, p4); | ||
157 | f2.uv1 = p1; | ||
158 | f2.uv2 = p2; | ||
159 | f2.uv3 = p4; | ||
160 | } | ||
161 | else | ||
162 | { | ||
163 | f1 = new Face(p1, p4, p3); | ||
164 | f2 = new Face(p1, p2, p4); | ||
165 | } | ||
166 | |||
167 | this.faces.Add(f1); | ||
168 | this.faces.Add(f2); | ||
169 | } | ||
170 | } | ||
171 | } | ||
172 | |||
173 | if (viewerMode) | ||
174 | calcVertexNormals(SculptType.plane, numXElements, numYElements); | ||
175 | } | ||
176 | |||
177 | #if SYSTEM_DRAWING | ||
178 | public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode) | ||
179 | { | ||
180 | _SculptMesh(sculptBitmap, sculptType, lod, viewerMode, false, false); | ||
181 | } | ||
182 | |||
183 | public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode, bool mirror, bool invert) | ||
184 | { | ||
185 | _SculptMesh(sculptBitmap, sculptType, lod, viewerMode, mirror, invert); | ||
186 | } | ||
187 | #endif | ||
188 | |||
189 | public SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool viewerMode, bool mirror, bool invert) | ||
190 | { | ||
191 | _SculptMesh(rows, sculptType, viewerMode, mirror, invert); | ||
192 | } | ||
193 | |||
194 | #if SYSTEM_DRAWING | ||
195 | /// <summary> | ||
196 | /// converts a bitmap to a list of lists of coords, while scaling the image. | ||
197 | /// the scaling is done in floating point so as to allow for reduced vertex position | ||
198 | /// quantization as the position will be averaged between pixel values. this routine will | ||
199 | /// likely fail if the bitmap width and height are not powers of 2. | ||
200 | /// </summary> | ||
201 | /// <param name="bitmap"></param> | ||
202 | /// <param name="scale"></param> | ||
203 | /// <param name="mirror"></param> | ||
204 | /// <returns></returns> | ||
205 | private List<List<Coord>> bitmap2Coords(Bitmap bitmap, int scale, bool mirror) | ||
206 | { | ||
207 | int numRows = bitmap.Height / scale; | ||
208 | int numCols = bitmap.Width / scale; | ||
209 | List<List<Coord>> rows = new List<List<Coord>>(numRows); | ||
210 | |||
211 | float pixScale = 1.0f / (scale * scale); | ||
212 | pixScale /= 255; | ||
213 | |||
214 | int imageX, imageY = 0; | ||
215 | |||
216 | int rowNdx, colNdx; | ||
217 | |||
218 | for (rowNdx = 0; rowNdx < numRows; rowNdx++) | ||
219 | { | ||
220 | List<Coord> row = new List<Coord>(numCols); | ||
221 | for (colNdx = 0; colNdx < numCols; colNdx++) | ||
222 | { | ||
223 | imageX = colNdx * scale; | ||
224 | int imageYStart = rowNdx * scale; | ||
225 | int imageYEnd = imageYStart + scale; | ||
226 | int imageXEnd = imageX + scale; | ||
227 | float rSum = 0.0f; | ||
228 | float gSum = 0.0f; | ||
229 | float bSum = 0.0f; | ||
230 | for (; imageX < imageXEnd; imageX++) | ||
231 | { | ||
232 | for (imageY = imageYStart; imageY < imageYEnd; imageY++) | ||
233 | { | ||
234 | Color c = bitmap.GetPixel(imageX, imageY); | ||
235 | if (c.A != 255) | ||
236 | { | ||
237 | bitmap.SetPixel(imageX, imageY, Color.FromArgb(255, c.R, c.G, c.B)); | ||
238 | c = bitmap.GetPixel(imageX, imageY); | ||
239 | } | ||
240 | rSum += c.R; | ||
241 | gSum += c.G; | ||
242 | bSum += c.B; | ||
243 | } | ||
244 | } | ||
245 | if (mirror) | ||
246 | row.Add(new Coord(-(rSum * pixScale - 0.5f), gSum * pixScale - 0.5f, bSum * pixScale - 0.5f)); | ||
247 | else | ||
248 | row.Add(new Coord(rSum * pixScale - 0.5f, gSum * pixScale - 0.5f, bSum * pixScale - 0.5f)); | ||
249 | |||
250 | } | ||
251 | rows.Add(row); | ||
252 | } | ||
253 | return rows; | ||
254 | } | ||
255 | |||
256 | private List<List<Coord>> bitmap2CoordsSampled(Bitmap bitmap, int scale, bool mirror) | ||
257 | { | ||
258 | int numRows = bitmap.Height / scale; | ||
259 | int numCols = bitmap.Width / scale; | ||
260 | List<List<Coord>> rows = new List<List<Coord>>(numRows); | ||
261 | |||
262 | float pixScale = 1.0f / 256.0f; | ||
263 | |||
264 | int imageX, imageY = 0; | ||
265 | |||
266 | int rowNdx, colNdx; | ||
267 | |||
268 | for (rowNdx = 0; rowNdx <= numRows; rowNdx++) | ||
269 | { | ||
270 | List<Coord> row = new List<Coord>(numCols); | ||
271 | imageY = rowNdx * scale; | ||
272 | if (rowNdx == numRows) imageY--; | ||
273 | for (colNdx = 0; colNdx <= numCols; colNdx++) | ||
274 | { | ||
275 | imageX = colNdx * scale; | ||
276 | if (colNdx == numCols) imageX--; | ||
277 | |||
278 | Color c = bitmap.GetPixel(imageX, imageY); | ||
279 | if (c.A != 255) | ||
280 | { | ||
281 | bitmap.SetPixel(imageX, imageY, Color.FromArgb(255, c.R, c.G, c.B)); | ||
282 | c = bitmap.GetPixel(imageX, imageY); | ||
283 | } | ||
284 | |||
285 | if (mirror) | ||
286 | row.Add(new Coord(-(c.R * pixScale - 0.5f), c.G * pixScale - 0.5f, c.B * pixScale - 0.5f)); | ||
287 | else | ||
288 | row.Add(new Coord(c.R * pixScale - 0.5f, c.G * pixScale - 0.5f, c.B * pixScale - 0.5f)); | ||
289 | |||
290 | } | ||
291 | rows.Add(row); | ||
292 | } | ||
293 | return rows; | ||
294 | } | ||
295 | |||
296 | |||
297 | void _SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode, bool mirror, bool invert) | ||
298 | { | ||
299 | _SculptMesh(new SculptMap(sculptBitmap, lod).ToRows(mirror), sculptType, viewerMode, mirror, invert); | ||
300 | } | ||
301 | #endif | ||
302 | |||
303 | void _SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool viewerMode, bool mirror, bool invert) | ||
304 | { | ||
305 | coords = new List<Coord>(); | ||
306 | faces = new List<Face>(); | ||
307 | normals = new List<Coord>(); | ||
308 | uvs = new List<UVCoord>(); | ||
309 | |||
310 | sculptType = (SculptType)(((int)sculptType) & 0x07); | ||
311 | |||
312 | if (mirror) | ||
313 | invert = !invert; | ||
314 | |||
315 | viewerFaces = new List<ViewerFace>(); | ||
316 | |||
317 | int width = rows[0].Count; | ||
318 | |||
319 | int p1, p2, p3, p4; | ||
320 | |||
321 | int imageX, imageY; | ||
322 | |||
323 | if (sculptType != SculptType.plane) | ||
324 | { | ||
325 | if (rows.Count % 2 == 0) | ||
326 | { | ||
327 | for (int rowNdx = 0; rowNdx < rows.Count; rowNdx++) | ||
328 | rows[rowNdx].Add(rows[rowNdx][0]); | ||
329 | } | ||
330 | else | ||
331 | { | ||
332 | int lastIndex = rows[0].Count - 1; | ||
333 | |||
334 | for (int i = 0; i < rows.Count; i++) | ||
335 | rows[i][0] = rows[i][lastIndex]; | ||
336 | } | ||
337 | } | ||
338 | |||
339 | Coord topPole = rows[0][width / 2]; | ||
340 | Coord bottomPole = rows[rows.Count - 1][width / 2]; | ||
341 | |||
342 | if (sculptType == SculptType.sphere) | ||
343 | { | ||
344 | if (rows.Count % 2 == 0) | ||
345 | { | ||
346 | int count = rows[0].Count; | ||
347 | List<Coord> topPoleRow = new List<Coord>(count); | ||
348 | List<Coord> bottomPoleRow = new List<Coord>(count); | ||
349 | |||
350 | for (int i = 0; i < count; i++) | ||
351 | { | ||
352 | topPoleRow.Add(topPole); | ||
353 | bottomPoleRow.Add(bottomPole); | ||
354 | } | ||
355 | rows.Insert(0, topPoleRow); | ||
356 | rows.Add(bottomPoleRow); | ||
357 | } | ||
358 | else | ||
359 | { | ||
360 | int count = rows[0].Count; | ||
361 | |||
362 | List<Coord> topPoleRow = rows[0]; | ||
363 | List<Coord> bottomPoleRow = rows[rows.Count - 1]; | ||
364 | |||
365 | for (int i = 0; i < count; i++) | ||
366 | { | ||
367 | topPoleRow[i] = topPole; | ||
368 | bottomPoleRow[i] = bottomPole; | ||
369 | } | ||
370 | } | ||
371 | } | ||
372 | |||
373 | if (sculptType == SculptType.torus) | ||
374 | rows.Add(rows[0]); | ||
375 | |||
376 | int coordsDown = rows.Count; | ||
377 | int coordsAcross = rows[0].Count; | ||
378 | // int lastColumn = coordsAcross - 1; | ||
379 | |||
380 | float widthUnit = 1.0f / (coordsAcross - 1); | ||
381 | float heightUnit = 1.0f / (coordsDown - 1); | ||
382 | |||
383 | for (imageY = 0; imageY < coordsDown; imageY++) | ||
384 | { | ||
385 | int rowOffset = imageY * coordsAcross; | ||
386 | |||
387 | for (imageX = 0; imageX < coordsAcross; imageX++) | ||
388 | { | ||
389 | /* | ||
390 | * p1-----p2 | ||
391 | * | \ f2 | | ||
392 | * | \ | | ||
393 | * | f1 \| | ||
394 | * p3-----p4 | ||
395 | */ | ||
396 | |||
397 | p4 = rowOffset + imageX; | ||
398 | p3 = p4 - 1; | ||
399 | |||
400 | p2 = p4 - coordsAcross; | ||
401 | p1 = p3 - coordsAcross; | ||
402 | |||
403 | this.coords.Add(rows[imageY][imageX]); | ||
404 | if (viewerMode) | ||
405 | { | ||
406 | this.normals.Add(new Coord()); | ||
407 | this.uvs.Add(new UVCoord(widthUnit * imageX, heightUnit * imageY)); | ||
408 | } | ||
409 | |||
410 | if (imageY > 0 && imageX > 0) | ||
411 | { | ||
412 | Face f1, f2; | ||
413 | |||
414 | if (viewerMode) | ||
415 | { | ||
416 | if (invert) | ||
417 | { | ||
418 | f1 = new Face(p1, p4, p3, p1, p4, p3); | ||
419 | f1.uv1 = p1; | ||
420 | f1.uv2 = p4; | ||
421 | f1.uv3 = p3; | ||
422 | |||
423 | f2 = new Face(p1, p2, p4, p1, p2, p4); | ||
424 | f2.uv1 = p1; | ||
425 | f2.uv2 = p2; | ||
426 | f2.uv3 = p4; | ||
427 | } | ||
428 | else | ||
429 | { | ||
430 | f1 = new Face(p1, p3, p4, p1, p3, p4); | ||
431 | f1.uv1 = p1; | ||
432 | f1.uv2 = p3; | ||
433 | f1.uv3 = p4; | ||
434 | |||
435 | f2 = new Face(p1, p4, p2, p1, p4, p2); | ||
436 | f2.uv1 = p1; | ||
437 | f2.uv2 = p4; | ||
438 | f2.uv3 = p2; | ||
439 | } | ||
440 | } | ||
441 | else | ||
442 | { | ||
443 | if (invert) | ||
444 | { | ||
445 | f1 = new Face(p1, p4, p3); | ||
446 | f2 = new Face(p1, p2, p4); | ||
447 | } | ||
448 | else | ||
449 | { | ||
450 | f1 = new Face(p1, p3, p4); | ||
451 | f2 = new Face(p1, p4, p2); | ||
452 | } | ||
453 | } | ||
454 | |||
455 | this.faces.Add(f1); | ||
456 | this.faces.Add(f2); | ||
457 | } | ||
458 | } | ||
459 | } | ||
460 | |||
461 | if (viewerMode) | ||
462 | calcVertexNormals(sculptType, coordsAcross, coordsDown); | ||
463 | } | ||
464 | |||
465 | /// <summary> | ||
466 | /// Duplicates a SculptMesh object. All object properties are copied by value, including lists. | ||
467 | /// </summary> | ||
468 | /// <returns></returns> | ||
469 | public SculptMesh Copy() | ||
470 | { | ||
471 | return new SculptMesh(this); | ||
472 | } | ||
473 | |||
474 | public SculptMesh(SculptMesh sm) | ||
475 | { | ||
476 | coords = new List<Coord>(sm.coords); | ||
477 | faces = new List<Face>(sm.faces); | ||
478 | viewerFaces = new List<ViewerFace>(sm.viewerFaces); | ||
479 | normals = new List<Coord>(sm.normals); | ||
480 | uvs = new List<UVCoord>(sm.uvs); | ||
481 | } | ||
482 | |||
483 | private void calcVertexNormals(SculptType sculptType, int xSize, int ySize) | ||
484 | { // compute vertex normals by summing all the surface normals of all the triangles sharing | ||
485 | // each vertex and then normalizing | ||
486 | int numFaces = this.faces.Count; | ||
487 | for (int i = 0; i < numFaces; i++) | ||
488 | { | ||
489 | Face face = this.faces[i]; | ||
490 | Coord surfaceNormal = face.SurfaceNormal(this.coords); | ||
491 | this.normals[face.n1] += surfaceNormal; | ||
492 | this.normals[face.n2] += surfaceNormal; | ||
493 | this.normals[face.n3] += surfaceNormal; | ||
494 | } | ||
495 | |||
496 | int numNormals = this.normals.Count; | ||
497 | for (int i = 0; i < numNormals; i++) | ||
498 | this.normals[i] = this.normals[i].Normalize(); | ||
499 | |||
500 | if (sculptType != SculptType.plane) | ||
501 | { // blend the vertex normals at the cylinder seam | ||
502 | for (int y = 0; y < ySize; y++) | ||
503 | { | ||
504 | int rowOffset = y * xSize; | ||
505 | |||
506 | this.normals[rowOffset] = this.normals[rowOffset + xSize - 1] = (this.normals[rowOffset] + this.normals[rowOffset + xSize - 1]).Normalize(); | ||
507 | } | ||
508 | } | ||
509 | |||
510 | foreach (Face face in this.faces) | ||
511 | { | ||
512 | ViewerFace vf = new ViewerFace(0); | ||
513 | vf.v1 = this.coords[face.v1]; | ||
514 | vf.v2 = this.coords[face.v2]; | ||
515 | vf.v3 = this.coords[face.v3]; | ||
516 | |||
517 | vf.coordIndex1 = face.v1; | ||
518 | vf.coordIndex2 = face.v2; | ||
519 | vf.coordIndex3 = face.v3; | ||
520 | |||
521 | vf.n1 = this.normals[face.n1]; | ||
522 | vf.n2 = this.normals[face.n2]; | ||
523 | vf.n3 = this.normals[face.n3]; | ||
524 | |||
525 | vf.uv1 = this.uvs[face.uv1]; | ||
526 | vf.uv2 = this.uvs[face.uv2]; | ||
527 | vf.uv3 = this.uvs[face.uv3]; | ||
528 | |||
529 | this.viewerFaces.Add(vf); | ||
530 | } | ||
531 | } | ||
532 | |||
533 | /// <summary> | ||
534 | /// Adds a value to each XYZ vertex coordinate in the mesh | ||
535 | /// </summary> | ||
536 | /// <param name="x"></param> | ||
537 | /// <param name="y"></param> | ||
538 | /// <param name="z"></param> | ||
539 | public void AddPos(float x, float y, float z) | ||
540 | { | ||
541 | int i; | ||
542 | int numVerts = this.coords.Count; | ||
543 | Coord vert; | ||
544 | |||
545 | for (i = 0; i < numVerts; i++) | ||
546 | { | ||
547 | vert = this.coords[i]; | ||
548 | vert.X += x; | ||
549 | vert.Y += y; | ||
550 | vert.Z += z; | ||
551 | this.coords[i] = vert; | ||
552 | } | ||
553 | |||
554 | if (this.viewerFaces != null) | ||
555 | { | ||
556 | int numViewerFaces = this.viewerFaces.Count; | ||
557 | |||
558 | for (i = 0; i < numViewerFaces; i++) | ||
559 | { | ||
560 | ViewerFace v = this.viewerFaces[i]; | ||
561 | v.AddPos(x, y, z); | ||
562 | this.viewerFaces[i] = v; | ||
563 | } | ||
564 | } | ||
565 | } | ||
566 | |||
567 | /// <summary> | ||
568 | /// Rotates the mesh | ||
569 | /// </summary> | ||
570 | /// <param name="q"></param> | ||
571 | public void AddRot(Quat q) | ||
572 | { | ||
573 | int i; | ||
574 | int numVerts = this.coords.Count; | ||
575 | |||
576 | for (i = 0; i < numVerts; i++) | ||
577 | this.coords[i] *= q; | ||
578 | |||
579 | int numNormals = this.normals.Count; | ||
580 | for (i = 0; i < numNormals; i++) | ||
581 | this.normals[i] *= q; | ||
582 | |||
583 | if (this.viewerFaces != null) | ||
584 | { | ||
585 | int numViewerFaces = this.viewerFaces.Count; | ||
586 | |||
587 | for (i = 0; i < numViewerFaces; i++) | ||
588 | { | ||
589 | ViewerFace v = this.viewerFaces[i]; | ||
590 | v.v1 *= q; | ||
591 | v.v2 *= q; | ||
592 | v.v3 *= q; | ||
593 | |||
594 | v.n1 *= q; | ||
595 | v.n2 *= q; | ||
596 | v.n3 *= q; | ||
597 | |||
598 | this.viewerFaces[i] = v; | ||
599 | } | ||
600 | } | ||
601 | } | ||
602 | |||
603 | public void Scale(float x, float y, float z) | ||
604 | { | ||
605 | int i; | ||
606 | int numVerts = this.coords.Count; | ||
607 | |||
608 | Coord m = new Coord(x, y, z); | ||
609 | for (i = 0; i < numVerts; i++) | ||
610 | this.coords[i] *= m; | ||
611 | |||
612 | if (this.viewerFaces != null) | ||
613 | { | ||
614 | int numViewerFaces = this.viewerFaces.Count; | ||
615 | for (i = 0; i < numViewerFaces; i++) | ||
616 | { | ||
617 | ViewerFace v = this.viewerFaces[i]; | ||
618 | v.v1 *= m; | ||
619 | v.v2 *= m; | ||
620 | v.v3 *= m; | ||
621 | this.viewerFaces[i] = v; | ||
622 | } | ||
623 | } | ||
624 | } | ||
625 | |||
626 | public void DumpRaw(String path, String name, String title) | ||
627 | { | ||
628 | if (path == null) | ||
629 | return; | ||
630 | String fileName = name + "_" + title + ".raw"; | ||
631 | String completePath = System.IO.Path.Combine(path, fileName); | ||
632 | StreamWriter sw = new StreamWriter(completePath); | ||
633 | |||
634 | for (int i = 0; i < this.faces.Count; i++) | ||
635 | { | ||
636 | string s = this.coords[this.faces[i].v1].ToString(); | ||
637 | s += " " + this.coords[this.faces[i].v2].ToString(); | ||
638 | s += " " + this.coords[this.faces[i].v3].ToString(); | ||
639 | |||
640 | sw.WriteLine(s); | ||
641 | } | ||
642 | |||
643 | sw.Close(); | ||
644 | } | ||
645 | } | ||
646 | } | ||
diff --git a/prebuild.xml b/prebuild.xml index 64e8e32..d009e87 100644 --- a/prebuild.xml +++ b/prebuild.xml | |||
@@ -701,6 +701,37 @@ | |||
701 | </Files> | 701 | </Files> |
702 | </Project> | 702 | </Project> |
703 | 703 | ||
704 | <Project frameworkVersion="v3_5" name="OpenSim.Region.Physics.UbitMeshing" path="OpenSim/Region/Physics/UbitMeshing" type="Library"> | ||
705 | <Configuration name="Debug"> | ||
706 | <Options> | ||
707 | <OutputPath>../../../../bin/Physics/</OutputPath> | ||
708 | </Options> | ||
709 | </Configuration> | ||
710 | <Configuration name="Release"> | ||
711 | <Options> | ||
712 | <OutputPath>../../../../bin/Physics/</OutputPath> | ||
713 | </Options> | ||
714 | </Configuration> | ||
715 | |||
716 | <ReferencePath>../../../../bin/</ReferencePath> | ||
717 | <Reference name="System"/> | ||
718 | <Reference name="System.Drawing"/> | ||
719 | <Reference name="CSJ2K" path="../../../../bin/"/> | ||
720 | <Reference name="OpenMetaverseTypes" path="../../../../bin/"/> | ||
721 | <Reference name="OpenMetaverse" path="../../../../bin/"/> | ||
722 | <Reference name="OpenMetaverse.StructuredData" path="../../../../bin/"/> | ||
723 | <Reference name="Nini" path="../../../../bin/"/> | ||
724 | <Reference name="OpenSim.Framework"/> | ||
725 | <Reference name="OpenSim.Framework.Console"/> | ||
726 | <Reference name="OpenSim.Region.Physics.Manager"/> | ||
727 | <Reference name="log4net" path="../../../../bin/"/> | ||
728 | <Reference name="zlib.net" path="../../../../bin/"/> | ||
729 | |||
730 | <Files> | ||
731 | <Match pattern="*.cs" recurse="true"/> | ||
732 | </Files> | ||
733 | </Project> | ||
734 | |||
704 | <Project frameworkVersion="v3_5" name="OpenSim.Capabilities" path="OpenSim/Capabilities" type="Library"> | 735 | <Project frameworkVersion="v3_5" name="OpenSim.Capabilities" path="OpenSim/Capabilities" type="Library"> |
705 | <Configuration name="Debug"> | 736 | <Configuration name="Debug"> |
706 | <Options> | 737 | <Options> |