diff options
author | Diva Canto | 2010-05-07 21:29:56 -0700 |
---|---|---|
committer | Diva Canto | 2010-05-07 21:29:56 -0700 |
commit | a58859a0d4206c194c9c56212218e2cafc2cc373 (patch) | |
tree | fed51a4e40c344b76f6b8b4d5c5b2ec0d2e142e4 /OpenSim/Region/Physics/Meshing/PrimMesher.cs | |
parent | improve handling of undersize sculpt textures (diff) | |
download | opensim-SC_OLD-a58859a0d4206c194c9c56212218e2cafc2cc373.zip opensim-SC_OLD-a58859a0d4206c194c9c56212218e2cafc2cc373.tar.gz opensim-SC_OLD-a58859a0d4206c194c9c56212218e2cafc2cc373.tar.bz2 opensim-SC_OLD-a58859a0d4206c194c9c56212218e2cafc2cc373.tar.xz |
GridUserService in place. Replaces the contrived concept of storing user's home and position info in the presence service. WARNING: I violated a taboo by deleting 2 migration files and simplifying the original table creation for Presence. This should not cause any problems to anyone, though. Things will work with the new simplified table, as well as with the previous contrived one. If there are any problems, solving them is as easy as dropping the presence table and deleting its row in the migrations table. The presence info only exists during a user's session anyway.
BTW, the Meshing files want to be committed too -- EOFs.
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Region/Physics/Meshing/PrimMesher.cs | 4568 |
1 files changed, 2284 insertions, 2284 deletions
diff --git a/OpenSim/Region/Physics/Meshing/PrimMesher.cs b/OpenSim/Region/Physics/Meshing/PrimMesher.cs index b4e101a..53022ad 100644 --- a/OpenSim/Region/Physics/Meshing/PrimMesher.cs +++ b/OpenSim/Region/Physics/Meshing/PrimMesher.cs | |||
@@ -1,2284 +1,2284 @@ | |||
1 | /* | 1 | /* |
2 | * Copyright (c) Contributors | 2 | * Copyright (c) Contributors |
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | 3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. |
4 | * | 4 | * |
5 | * Redistribution and use in source and binary forms, with or without | 5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions are met: | 6 | * modification, are permitted provided that the following conditions are met: |
7 | * * Redistributions of source code must retain the above copyright | 7 | * * Redistributions of source code must retain the above copyright |
8 | * notice, this list of conditions and the following disclaimer. | 8 | * notice, this list of conditions and the following disclaimer. |
9 | * * Redistributions in binary form must reproduce the above copyright | 9 | * * Redistributions in binary form must reproduce the above copyright |
10 | * notice, this list of conditions and the following disclaimer in the | 10 | * notice, this list of conditions and the following disclaimer in the |
11 | * documentation and/or other materials provided with the distribution. | 11 | * documentation and/or other materials provided with the distribution. |
12 | * * Neither the name of the OpenSimulator Project nor the | 12 | * * Neither the name of the OpenSimulator Project nor the |
13 | * names of its contributors may be used to endorse or promote products | 13 | * names of its contributors may be used to endorse or promote products |
14 | * derived from this software without specific prior written permission. | 14 | * derived from this software without specific prior written permission. |
15 | * | 15 | * |
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | 16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY |
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | 17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | 18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | 19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY |
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | 20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | 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 | 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 | 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 | 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. | 25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 | */ | 26 | */ |
27 | 27 | ||
28 | using System; | 28 | using System; |
29 | using System.Collections.Generic; | 29 | using System.Collections.Generic; |
30 | using System.Text; | 30 | using System.Text; |
31 | using System.IO; | 31 | using System.IO; |
32 | 32 | ||
33 | namespace PrimMesher | 33 | namespace PrimMesher |
34 | { | 34 | { |
35 | public struct Quat | 35 | public struct Quat |
36 | { | 36 | { |
37 | /// <summary>X value</summary> | 37 | /// <summary>X value</summary> |
38 | public float X; | 38 | public float X; |
39 | /// <summary>Y value</summary> | 39 | /// <summary>Y value</summary> |
40 | public float Y; | 40 | public float Y; |
41 | /// <summary>Z value</summary> | 41 | /// <summary>Z value</summary> |
42 | public float Z; | 42 | public float Z; |
43 | /// <summary>W value</summary> | 43 | /// <summary>W value</summary> |
44 | public float W; | 44 | public float W; |
45 | 45 | ||
46 | public Quat(float x, float y, float z, float w) | 46 | public Quat(float x, float y, float z, float w) |
47 | { | 47 | { |
48 | X = x; | 48 | X = x; |
49 | Y = y; | 49 | Y = y; |
50 | Z = z; | 50 | Z = z; |
51 | W = w; | 51 | W = w; |
52 | } | 52 | } |
53 | 53 | ||
54 | public Quat(Coord axis, float angle) | 54 | public Quat(Coord axis, float angle) |
55 | { | 55 | { |
56 | axis = axis.Normalize(); | 56 | axis = axis.Normalize(); |
57 | 57 | ||
58 | angle *= 0.5f; | 58 | angle *= 0.5f; |
59 | float c = (float)Math.Cos(angle); | 59 | float c = (float)Math.Cos(angle); |
60 | float s = (float)Math.Sin(angle); | 60 | float s = (float)Math.Sin(angle); |
61 | 61 | ||
62 | X = axis.X * s; | 62 | X = axis.X * s; |
63 | Y = axis.Y * s; | 63 | Y = axis.Y * s; |
64 | Z = axis.Z * s; | 64 | Z = axis.Z * s; |
65 | W = c; | 65 | W = c; |
66 | 66 | ||
67 | Normalize(); | 67 | Normalize(); |
68 | } | 68 | } |
69 | 69 | ||
70 | public float Length() | 70 | public float Length() |
71 | { | 71 | { |
72 | return (float)Math.Sqrt(X * X + Y * Y + Z * Z + W * W); | 72 | return (float)Math.Sqrt(X * X + Y * Y + Z * Z + W * W); |
73 | } | 73 | } |
74 | 74 | ||
75 | public Quat Normalize() | 75 | public Quat Normalize() |
76 | { | 76 | { |
77 | const float MAG_THRESHOLD = 0.0000001f; | 77 | const float MAG_THRESHOLD = 0.0000001f; |
78 | float mag = Length(); | 78 | float mag = Length(); |
79 | 79 | ||
80 | // Catch very small rounding errors when normalizing | 80 | // Catch very small rounding errors when normalizing |
81 | if (mag > MAG_THRESHOLD) | 81 | if (mag > MAG_THRESHOLD) |
82 | { | 82 | { |
83 | float oomag = 1f / mag; | 83 | float oomag = 1f / mag; |
84 | X *= oomag; | 84 | X *= oomag; |
85 | Y *= oomag; | 85 | Y *= oomag; |
86 | Z *= oomag; | 86 | Z *= oomag; |
87 | W *= oomag; | 87 | W *= oomag; |
88 | } | 88 | } |
89 | else | 89 | else |
90 | { | 90 | { |
91 | X = 0f; | 91 | X = 0f; |
92 | Y = 0f; | 92 | Y = 0f; |
93 | Z = 0f; | 93 | Z = 0f; |
94 | W = 1f; | 94 | W = 1f; |
95 | } | 95 | } |
96 | 96 | ||
97 | return this; | 97 | return this; |
98 | } | 98 | } |
99 | 99 | ||
100 | public static Quat operator *(Quat q1, Quat q2) | 100 | public static Quat operator *(Quat q1, Quat q2) |
101 | { | 101 | { |
102 | float x = q1.W * q2.X + q1.X * q2.W + q1.Y * q2.Z - q1.Z * q2.Y; | 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; | 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; | 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; | 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); | 106 | return new Quat(x, y, z, w); |
107 | } | 107 | } |
108 | 108 | ||
109 | public override string ToString() | 109 | public override string ToString() |
110 | { | 110 | { |
111 | return "< X: " + this.X.ToString() + ", Y: " + this.Y.ToString() + ", Z: " + this.Z.ToString() + ", W: " + this.W.ToString() + ">"; | 111 | return "< X: " + this.X.ToString() + ", Y: " + this.Y.ToString() + ", Z: " + this.Z.ToString() + ", W: " + this.W.ToString() + ">"; |
112 | } | 112 | } |
113 | } | 113 | } |
114 | 114 | ||
115 | public struct Coord | 115 | public struct Coord |
116 | { | 116 | { |
117 | public float X; | 117 | public float X; |
118 | public float Y; | 118 | public float Y; |
119 | public float Z; | 119 | public float Z; |
120 | 120 | ||
121 | public Coord(float x, float y, float z) | 121 | public Coord(float x, float y, float z) |
122 | { | 122 | { |
123 | this.X = x; | 123 | this.X = x; |
124 | this.Y = y; | 124 | this.Y = y; |
125 | this.Z = z; | 125 | this.Z = z; |
126 | } | 126 | } |
127 | 127 | ||
128 | public float Length() | 128 | public float Length() |
129 | { | 129 | { |
130 | return (float)Math.Sqrt(this.X * this.X + this.Y * this.Y + this.Z * this.Z); | 130 | return (float)Math.Sqrt(this.X * this.X + this.Y * this.Y + this.Z * this.Z); |
131 | } | 131 | } |
132 | 132 | ||
133 | public Coord Invert() | 133 | public Coord Invert() |
134 | { | 134 | { |
135 | this.X = -this.X; | 135 | this.X = -this.X; |
136 | this.Y = -this.Y; | 136 | this.Y = -this.Y; |
137 | this.Z = -this.Z; | 137 | this.Z = -this.Z; |
138 | 138 | ||
139 | return this; | 139 | return this; |
140 | } | 140 | } |
141 | 141 | ||
142 | public Coord Normalize() | 142 | public Coord Normalize() |
143 | { | 143 | { |
144 | const float MAG_THRESHOLD = 0.0000001f; | 144 | const float MAG_THRESHOLD = 0.0000001f; |
145 | float mag = Length(); | 145 | float mag = Length(); |
146 | 146 | ||
147 | // Catch very small rounding errors when normalizing | 147 | // Catch very small rounding errors when normalizing |
148 | if (mag > MAG_THRESHOLD) | 148 | if (mag > MAG_THRESHOLD) |
149 | { | 149 | { |
150 | float oomag = 1.0f / mag; | 150 | float oomag = 1.0f / mag; |
151 | this.X *= oomag; | 151 | this.X *= oomag; |
152 | this.Y *= oomag; | 152 | this.Y *= oomag; |
153 | this.Z *= oomag; | 153 | this.Z *= oomag; |
154 | } | 154 | } |
155 | else | 155 | else |
156 | { | 156 | { |
157 | this.X = 0.0f; | 157 | this.X = 0.0f; |
158 | this.Y = 0.0f; | 158 | this.Y = 0.0f; |
159 | this.Z = 0.0f; | 159 | this.Z = 0.0f; |
160 | } | 160 | } |
161 | 161 | ||
162 | return this; | 162 | return this; |
163 | } | 163 | } |
164 | 164 | ||
165 | public override string ToString() | 165 | public override string ToString() |
166 | { | 166 | { |
167 | return this.X.ToString() + " " + this.Y.ToString() + " " + this.Z.ToString(); | 167 | return this.X.ToString() + " " + this.Y.ToString() + " " + this.Z.ToString(); |
168 | } | 168 | } |
169 | 169 | ||
170 | public static Coord Cross(Coord c1, Coord c2) | 170 | public static Coord Cross(Coord c1, Coord c2) |
171 | { | 171 | { |
172 | return new Coord( | 172 | return new Coord( |
173 | c1.Y * c2.Z - c2.Y * c1.Z, | 173 | c1.Y * c2.Z - c2.Y * c1.Z, |
174 | c1.Z * c2.X - c2.Z * c1.X, | 174 | c1.Z * c2.X - c2.Z * c1.X, |
175 | c1.X * c2.Y - c2.X * c1.Y | 175 | c1.X * c2.Y - c2.X * c1.Y |
176 | ); | 176 | ); |
177 | } | 177 | } |
178 | 178 | ||
179 | public static Coord operator +(Coord v, Coord a) | 179 | public static Coord operator +(Coord v, Coord a) |
180 | { | 180 | { |
181 | return new Coord(v.X + a.X, v.Y + a.Y, v.Z + a.Z); | 181 | return new Coord(v.X + a.X, v.Y + a.Y, v.Z + a.Z); |
182 | } | 182 | } |
183 | 183 | ||
184 | public static Coord operator *(Coord v, Coord m) | 184 | public static Coord operator *(Coord v, Coord m) |
185 | { | 185 | { |
186 | return new Coord(v.X * m.X, v.Y * m.Y, v.Z * m.Z); | 186 | return new Coord(v.X * m.X, v.Y * m.Y, v.Z * m.Z); |
187 | } | 187 | } |
188 | 188 | ||
189 | public static Coord operator *(Coord v, Quat q) | 189 | public static Coord operator *(Coord v, Quat q) |
190 | { | 190 | { |
191 | // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/ | 191 | // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/ |
192 | 192 | ||
193 | Coord c2 = new Coord(0.0f, 0.0f, 0.0f); | 193 | Coord c2 = new Coord(0.0f, 0.0f, 0.0f); |
194 | 194 | ||
195 | c2.X = q.W * q.W * v.X + | 195 | c2.X = q.W * q.W * v.X + |
196 | 2f * q.Y * q.W * v.Z - | 196 | 2f * q.Y * q.W * v.Z - |
197 | 2f * q.Z * q.W * v.Y + | 197 | 2f * q.Z * q.W * v.Y + |
198 | q.X * q.X * v.X + | 198 | q.X * q.X * v.X + |
199 | 2f * q.Y * q.X * v.Y + | 199 | 2f * q.Y * q.X * v.Y + |
200 | 2f * q.Z * q.X * v.Z - | 200 | 2f * q.Z * q.X * v.Z - |
201 | q.Z * q.Z * v.X - | 201 | q.Z * q.Z * v.X - |
202 | q.Y * q.Y * v.X; | 202 | q.Y * q.Y * v.X; |
203 | 203 | ||
204 | c2.Y = | 204 | c2.Y = |
205 | 2f * q.X * q.Y * v.X + | 205 | 2f * q.X * q.Y * v.X + |
206 | q.Y * q.Y * v.Y + | 206 | q.Y * q.Y * v.Y + |
207 | 2f * q.Z * q.Y * v.Z + | 207 | 2f * q.Z * q.Y * v.Z + |
208 | 2f * q.W * q.Z * v.X - | 208 | 2f * q.W * q.Z * v.X - |
209 | q.Z * q.Z * v.Y + | 209 | q.Z * q.Z * v.Y + |
210 | q.W * q.W * v.Y - | 210 | q.W * q.W * v.Y - |
211 | 2f * q.X * q.W * v.Z - | 211 | 2f * q.X * q.W * v.Z - |
212 | q.X * q.X * v.Y; | 212 | q.X * q.X * v.Y; |
213 | 213 | ||
214 | c2.Z = | 214 | c2.Z = |
215 | 2f * q.X * q.Z * v.X + | 215 | 2f * q.X * q.Z * v.X + |
216 | 2f * q.Y * q.Z * v.Y + | 216 | 2f * q.Y * q.Z * v.Y + |
217 | q.Z * q.Z * v.Z - | 217 | q.Z * q.Z * v.Z - |
218 | 2f * q.W * q.Y * v.X - | 218 | 2f * q.W * q.Y * v.X - |
219 | q.Y * q.Y * v.Z + | 219 | q.Y * q.Y * v.Z + |
220 | 2f * q.W * q.X * v.Y - | 220 | 2f * q.W * q.X * v.Y - |
221 | q.X * q.X * v.Z + | 221 | q.X * q.X * v.Z + |
222 | q.W * q.W * v.Z; | 222 | q.W * q.W * v.Z; |
223 | 223 | ||
224 | return c2; | 224 | return c2; |
225 | } | 225 | } |
226 | } | 226 | } |
227 | 227 | ||
228 | public struct UVCoord | 228 | public struct UVCoord |
229 | { | 229 | { |
230 | public float U; | 230 | public float U; |
231 | public float V; | 231 | public float V; |
232 | 232 | ||
233 | 233 | ||
234 | public UVCoord(float u, float v) | 234 | public UVCoord(float u, float v) |
235 | { | 235 | { |
236 | this.U = u; | 236 | this.U = u; |
237 | this.V = v; | 237 | this.V = v; |
238 | } | 238 | } |
239 | } | 239 | } |
240 | 240 | ||
241 | public struct Face | 241 | public struct Face |
242 | { | 242 | { |
243 | public int primFace; | 243 | public int primFace; |
244 | 244 | ||
245 | // vertices | 245 | // vertices |
246 | public int v1; | 246 | public int v1; |
247 | public int v2; | 247 | public int v2; |
248 | public int v3; | 248 | public int v3; |
249 | 249 | ||
250 | //normals | 250 | //normals |
251 | public int n1; | 251 | public int n1; |
252 | public int n2; | 252 | public int n2; |
253 | public int n3; | 253 | public int n3; |
254 | 254 | ||
255 | // uvs | 255 | // uvs |
256 | public int uv1; | 256 | public int uv1; |
257 | public int uv2; | 257 | public int uv2; |
258 | public int uv3; | 258 | public int uv3; |
259 | 259 | ||
260 | public Face(int v1, int v2, int v3) | 260 | public Face(int v1, int v2, int v3) |
261 | { | 261 | { |
262 | primFace = 0; | 262 | primFace = 0; |
263 | 263 | ||
264 | this.v1 = v1; | 264 | this.v1 = v1; |
265 | this.v2 = v2; | 265 | this.v2 = v2; |
266 | this.v3 = v3; | 266 | this.v3 = v3; |
267 | 267 | ||
268 | this.n1 = 0; | 268 | this.n1 = 0; |
269 | this.n2 = 0; | 269 | this.n2 = 0; |
270 | this.n3 = 0; | 270 | this.n3 = 0; |
271 | 271 | ||
272 | this.uv1 = 0; | 272 | this.uv1 = 0; |
273 | this.uv2 = 0; | 273 | this.uv2 = 0; |
274 | this.uv3 = 0; | 274 | this.uv3 = 0; |
275 | 275 | ||
276 | } | 276 | } |
277 | 277 | ||
278 | public Face(int v1, int v2, int v3, int n1, int n2, int n3) | 278 | public Face(int v1, int v2, int v3, int n1, int n2, int n3) |
279 | { | 279 | { |
280 | primFace = 0; | 280 | primFace = 0; |
281 | 281 | ||
282 | this.v1 = v1; | 282 | this.v1 = v1; |
283 | this.v2 = v2; | 283 | this.v2 = v2; |
284 | this.v3 = v3; | 284 | this.v3 = v3; |
285 | 285 | ||
286 | this.n1 = n1; | 286 | this.n1 = n1; |
287 | this.n2 = n2; | 287 | this.n2 = n2; |
288 | this.n3 = n3; | 288 | this.n3 = n3; |
289 | 289 | ||
290 | this.uv1 = 0; | 290 | this.uv1 = 0; |
291 | this.uv2 = 0; | 291 | this.uv2 = 0; |
292 | this.uv3 = 0; | 292 | this.uv3 = 0; |
293 | } | 293 | } |
294 | 294 | ||
295 | public Coord SurfaceNormal(List<Coord> coordList) | 295 | public Coord SurfaceNormal(List<Coord> coordList) |
296 | { | 296 | { |
297 | Coord c1 = coordList[this.v1]; | 297 | Coord c1 = coordList[this.v1]; |
298 | Coord c2 = coordList[this.v2]; | 298 | Coord c2 = coordList[this.v2]; |
299 | Coord c3 = coordList[this.v3]; | 299 | Coord c3 = coordList[this.v3]; |
300 | 300 | ||
301 | Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z); | 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); | 302 | Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z); |
303 | 303 | ||
304 | return Coord.Cross(edge1, edge2).Normalize(); | 304 | return Coord.Cross(edge1, edge2).Normalize(); |
305 | } | 305 | } |
306 | } | 306 | } |
307 | 307 | ||
308 | public struct ViewerFace | 308 | public struct ViewerFace |
309 | { | 309 | { |
310 | public int primFaceNumber; | 310 | public int primFaceNumber; |
311 | 311 | ||
312 | public Coord v1; | 312 | public Coord v1; |
313 | public Coord v2; | 313 | public Coord v2; |
314 | public Coord v3; | 314 | public Coord v3; |
315 | 315 | ||
316 | public int coordIndex1; | 316 | public int coordIndex1; |
317 | public int coordIndex2; | 317 | public int coordIndex2; |
318 | public int coordIndex3; | 318 | public int coordIndex3; |
319 | 319 | ||
320 | public Coord n1; | 320 | public Coord n1; |
321 | public Coord n2; | 321 | public Coord n2; |
322 | public Coord n3; | 322 | public Coord n3; |
323 | 323 | ||
324 | public UVCoord uv1; | 324 | public UVCoord uv1; |
325 | public UVCoord uv2; | 325 | public UVCoord uv2; |
326 | public UVCoord uv3; | 326 | public UVCoord uv3; |
327 | 327 | ||
328 | public ViewerFace(int primFaceNumber) | 328 | public ViewerFace(int primFaceNumber) |
329 | { | 329 | { |
330 | this.primFaceNumber = primFaceNumber; | 330 | this.primFaceNumber = primFaceNumber; |
331 | 331 | ||
332 | this.v1 = new Coord(); | 332 | this.v1 = new Coord(); |
333 | this.v2 = new Coord(); | 333 | this.v2 = new Coord(); |
334 | this.v3 = new Coord(); | 334 | this.v3 = new Coord(); |
335 | 335 | ||
336 | this.coordIndex1 = this.coordIndex2 = this.coordIndex3 = -1; // -1 means not assigned yet | 336 | this.coordIndex1 = this.coordIndex2 = this.coordIndex3 = -1; // -1 means not assigned yet |
337 | 337 | ||
338 | this.n1 = new Coord(); | 338 | this.n1 = new Coord(); |
339 | this.n2 = new Coord(); | 339 | this.n2 = new Coord(); |
340 | this.n3 = new Coord(); | 340 | this.n3 = new Coord(); |
341 | 341 | ||
342 | this.uv1 = new UVCoord(); | 342 | this.uv1 = new UVCoord(); |
343 | this.uv2 = new UVCoord(); | 343 | this.uv2 = new UVCoord(); |
344 | this.uv3 = new UVCoord(); | 344 | this.uv3 = new UVCoord(); |
345 | } | 345 | } |
346 | 346 | ||
347 | public void Scale(float x, float y, float z) | 347 | public void Scale(float x, float y, float z) |
348 | { | 348 | { |
349 | this.v1.X *= x; | 349 | this.v1.X *= x; |
350 | this.v1.Y *= y; | 350 | this.v1.Y *= y; |
351 | this.v1.Z *= z; | 351 | this.v1.Z *= z; |
352 | 352 | ||
353 | this.v2.X *= x; | 353 | this.v2.X *= x; |
354 | this.v2.Y *= y; | 354 | this.v2.Y *= y; |
355 | this.v2.Z *= z; | 355 | this.v2.Z *= z; |
356 | 356 | ||
357 | this.v3.X *= x; | 357 | this.v3.X *= x; |
358 | this.v3.Y *= y; | 358 | this.v3.Y *= y; |
359 | this.v3.Z *= z; | 359 | this.v3.Z *= z; |
360 | } | 360 | } |
361 | 361 | ||
362 | public void AddPos(float x, float y, float z) | 362 | public void AddPos(float x, float y, float z) |
363 | { | 363 | { |
364 | this.v1.X += x; | 364 | this.v1.X += x; |
365 | this.v2.X += x; | 365 | this.v2.X += x; |
366 | this.v3.X += x; | 366 | this.v3.X += x; |
367 | 367 | ||
368 | this.v1.Y += y; | 368 | this.v1.Y += y; |
369 | this.v2.Y += y; | 369 | this.v2.Y += y; |
370 | this.v3.Y += y; | 370 | this.v3.Y += y; |
371 | 371 | ||
372 | this.v1.Z += z; | 372 | this.v1.Z += z; |
373 | this.v2.Z += z; | 373 | this.v2.Z += z; |
374 | this.v3.Z += z; | 374 | this.v3.Z += z; |
375 | } | 375 | } |
376 | 376 | ||
377 | public void AddRot(Quat q) | 377 | public void AddRot(Quat q) |
378 | { | 378 | { |
379 | this.v1 *= q; | 379 | this.v1 *= q; |
380 | this.v2 *= q; | 380 | this.v2 *= q; |
381 | this.v3 *= q; | 381 | this.v3 *= q; |
382 | 382 | ||
383 | this.n1 *= q; | 383 | this.n1 *= q; |
384 | this.n2 *= q; | 384 | this.n2 *= q; |
385 | this.n3 *= q; | 385 | this.n3 *= q; |
386 | } | 386 | } |
387 | 387 | ||
388 | public void CalcSurfaceNormal() | 388 | public void CalcSurfaceNormal() |
389 | { | 389 | { |
390 | 390 | ||
391 | Coord edge1 = new Coord(this.v2.X - this.v1.X, this.v2.Y - this.v1.Y, this.v2.Z - this.v1.Z); | 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); | 392 | Coord edge2 = new Coord(this.v3.X - this.v1.X, this.v3.Y - this.v1.Y, this.v3.Z - this.v1.Z); |
393 | 393 | ||
394 | this.n1 = this.n2 = this.n3 = Coord.Cross(edge1, edge2).Normalize(); | 394 | this.n1 = this.n2 = this.n3 = Coord.Cross(edge1, edge2).Normalize(); |
395 | } | 395 | } |
396 | } | 396 | } |
397 | 397 | ||
398 | internal struct Angle | 398 | internal struct Angle |
399 | { | 399 | { |
400 | internal float angle; | 400 | internal float angle; |
401 | internal float X; | 401 | internal float X; |
402 | internal float Y; | 402 | internal float Y; |
403 | 403 | ||
404 | internal Angle(float angle, float x, float y) | 404 | internal Angle(float angle, float x, float y) |
405 | { | 405 | { |
406 | this.angle = angle; | 406 | this.angle = angle; |
407 | this.X = x; | 407 | this.X = x; |
408 | this.Y = y; | 408 | this.Y = y; |
409 | } | 409 | } |
410 | } | 410 | } |
411 | 411 | ||
412 | internal class AngleList | 412 | internal class AngleList |
413 | { | 413 | { |
414 | private float iX, iY; // intersection point | 414 | private float iX, iY; // intersection point |
415 | 415 | ||
416 | private static Angle[] angles3 = | 416 | private static Angle[] angles3 = |
417 | { | 417 | { |
418 | new Angle(0.0f, 1.0f, 0.0f), | 418 | new Angle(0.0f, 1.0f, 0.0f), |
419 | new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f), | 419 | new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f), |
420 | new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f), | 420 | new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f), |
421 | new Angle(1.0f, 1.0f, 0.0f) | 421 | new Angle(1.0f, 1.0f, 0.0f) |
422 | }; | 422 | }; |
423 | 423 | ||
424 | private static Coord[] normals3 = | 424 | private static Coord[] normals3 = |
425 | { | 425 | { |
426 | new Coord(0.25f, 0.4330127019f, 0.0f).Normalize(), | 426 | new Coord(0.25f, 0.4330127019f, 0.0f).Normalize(), |
427 | new Coord(-0.5f, 0.0f, 0.0f).Normalize(), | 427 | new Coord(-0.5f, 0.0f, 0.0f).Normalize(), |
428 | new Coord(0.25f, -0.4330127019f, 0.0f).Normalize(), | 428 | new Coord(0.25f, -0.4330127019f, 0.0f).Normalize(), |
429 | new Coord(0.25f, 0.4330127019f, 0.0f).Normalize() | 429 | new Coord(0.25f, 0.4330127019f, 0.0f).Normalize() |
430 | }; | 430 | }; |
431 | 431 | ||
432 | private static Angle[] angles4 = | 432 | private static Angle[] angles4 = |
433 | { | 433 | { |
434 | new Angle(0.0f, 1.0f, 0.0f), | 434 | new Angle(0.0f, 1.0f, 0.0f), |
435 | new Angle(0.25f, 0.0f, 1.0f), | 435 | new Angle(0.25f, 0.0f, 1.0f), |
436 | new Angle(0.5f, -1.0f, 0.0f), | 436 | new Angle(0.5f, -1.0f, 0.0f), |
437 | new Angle(0.75f, 0.0f, -1.0f), | 437 | new Angle(0.75f, 0.0f, -1.0f), |
438 | new Angle(1.0f, 1.0f, 0.0f) | 438 | new Angle(1.0f, 1.0f, 0.0f) |
439 | }; | 439 | }; |
440 | 440 | ||
441 | private static Coord[] normals4 = | 441 | private static Coord[] normals4 = |
442 | { | 442 | { |
443 | new Coord(0.5f, 0.5f, 0.0f).Normalize(), | 443 | new Coord(0.5f, 0.5f, 0.0f).Normalize(), |
444 | 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(), | 445 | new Coord(-0.5f, -0.5f, 0.0f).Normalize(), |
446 | 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() | 447 | new Coord(0.5f, 0.5f, 0.0f).Normalize() |
448 | }; | 448 | }; |
449 | 449 | ||
450 | private static Angle[] angles24 = | 450 | private static Angle[] angles24 = |
451 | { | 451 | { |
452 | new Angle(0.0f, 1.0f, 0.0f), | 452 | new Angle(0.0f, 1.0f, 0.0f), |
453 | new Angle(0.041666666666666664f, 0.96592582628906831f, 0.25881904510252074f), | 453 | new Angle(0.041666666666666664f, 0.96592582628906831f, 0.25881904510252074f), |
454 | new Angle(0.083333333333333329f, 0.86602540378443871f, 0.5f), | 454 | new Angle(0.083333333333333329f, 0.86602540378443871f, 0.5f), |
455 | new Angle(0.125f, 0.70710678118654757f, 0.70710678118654746f), | 455 | new Angle(0.125f, 0.70710678118654757f, 0.70710678118654746f), |
456 | new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f), | 456 | new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f), |
457 | new Angle(0.20833333333333331f, 0.25881904510252096f, 0.9659258262890682f), | 457 | new Angle(0.20833333333333331f, 0.25881904510252096f, 0.9659258262890682f), |
458 | new Angle(0.25f, 0.0f, 1.0f), | 458 | new Angle(0.25f, 0.0f, 1.0f), |
459 | new Angle(0.29166666666666663f, -0.25881904510252063f, 0.96592582628906831f), | 459 | new Angle(0.29166666666666663f, -0.25881904510252063f, 0.96592582628906831f), |
460 | new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f), | 460 | new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f), |
461 | new Angle(0.375f, -0.70710678118654746f, 0.70710678118654757f), | 461 | new Angle(0.375f, -0.70710678118654746f, 0.70710678118654757f), |
462 | new Angle(0.41666666666666663f, -0.86602540378443849f, 0.5f), | 462 | new Angle(0.41666666666666663f, -0.86602540378443849f, 0.5f), |
463 | new Angle(0.45833333333333331f, -0.9659258262890682f, 0.25881904510252102f), | 463 | new Angle(0.45833333333333331f, -0.9659258262890682f, 0.25881904510252102f), |
464 | new Angle(0.5f, -1.0f, 0.0f), | 464 | new Angle(0.5f, -1.0f, 0.0f), |
465 | new Angle(0.54166666666666663f, -0.96592582628906842f, -0.25881904510252035f), | 465 | new Angle(0.54166666666666663f, -0.96592582628906842f, -0.25881904510252035f), |
466 | new Angle(0.58333333333333326f, -0.86602540378443882f, -0.5f), | 466 | new Angle(0.58333333333333326f, -0.86602540378443882f, -0.5f), |
467 | new Angle(0.62499999999999989f, -0.70710678118654791f, -0.70710678118654713f), | 467 | new Angle(0.62499999999999989f, -0.70710678118654791f, -0.70710678118654713f), |
468 | new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f), | 468 | new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f), |
469 | new Angle(0.70833333333333326f, -0.25881904510252152f, -0.96592582628906809f), | 469 | new Angle(0.70833333333333326f, -0.25881904510252152f, -0.96592582628906809f), |
470 | new Angle(0.75f, 0.0f, -1.0f), | 470 | new Angle(0.75f, 0.0f, -1.0f), |
471 | new Angle(0.79166666666666663f, 0.2588190451025203f, -0.96592582628906842f), | 471 | new Angle(0.79166666666666663f, 0.2588190451025203f, -0.96592582628906842f), |
472 | new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f), | 472 | new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f), |
473 | new Angle(0.875f, 0.70710678118654735f, -0.70710678118654768f), | 473 | new Angle(0.875f, 0.70710678118654735f, -0.70710678118654768f), |
474 | new Angle(0.91666666666666663f, 0.86602540378443837f, -0.5f), | 474 | new Angle(0.91666666666666663f, 0.86602540378443837f, -0.5f), |
475 | new Angle(0.95833333333333326f, 0.96592582628906809f, -0.25881904510252157f), | 475 | new Angle(0.95833333333333326f, 0.96592582628906809f, -0.25881904510252157f), |
476 | new Angle(1.0f, 1.0f, 0.0f) | 476 | new Angle(1.0f, 1.0f, 0.0f) |
477 | }; | 477 | }; |
478 | 478 | ||
479 | private Angle interpolatePoints(float newPoint, Angle p1, Angle p2) | 479 | private Angle interpolatePoints(float newPoint, Angle p1, Angle p2) |
480 | { | 480 | { |
481 | float m = (newPoint - p1.angle) / (p2.angle - p1.angle); | 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)); | 482 | return new Angle(newPoint, p1.X + m * (p2.X - p1.X), p1.Y + m * (p2.Y - p1.Y)); |
483 | } | 483 | } |
484 | 484 | ||
485 | private void intersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) | 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/ | 486 | { // ref: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/ |
487 | double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); | 487 | double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); |
488 | double uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3); | 488 | double uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3); |
489 | 489 | ||
490 | if (denom != 0.0) | 490 | if (denom != 0.0) |
491 | { | 491 | { |
492 | double ua = uaNumerator / denom; | 492 | double ua = uaNumerator / denom; |
493 | iX = (float)(x1 + ua * (x2 - x1)); | 493 | iX = (float)(x1 + ua * (x2 - x1)); |
494 | iY = (float)(y1 + ua * (y2 - y1)); | 494 | iY = (float)(y1 + ua * (y2 - y1)); |
495 | } | 495 | } |
496 | } | 496 | } |
497 | 497 | ||
498 | internal List<Angle> angles; | 498 | internal List<Angle> angles; |
499 | internal List<Coord> normals; | 499 | internal List<Coord> normals; |
500 | 500 | ||
501 | internal void makeAngles(int sides, float startAngle, float stopAngle) | 501 | internal void makeAngles(int sides, float startAngle, float stopAngle) |
502 | { | 502 | { |
503 | angles = new List<Angle>(); | 503 | angles = new List<Angle>(); |
504 | normals = new List<Coord>(); | 504 | normals = new List<Coord>(); |
505 | 505 | ||
506 | double twoPi = System.Math.PI * 2.0; | 506 | double twoPi = System.Math.PI * 2.0; |
507 | float twoPiInv = 1.0f / (float)twoPi; | 507 | float twoPiInv = 1.0f / (float)twoPi; |
508 | 508 | ||
509 | if (sides < 1) | 509 | if (sides < 1) |
510 | throw new Exception("number of sides not greater than zero"); | 510 | throw new Exception("number of sides not greater than zero"); |
511 | if (stopAngle <= startAngle) | 511 | if (stopAngle <= startAngle) |
512 | throw new Exception("stopAngle not greater than startAngle"); | 512 | throw new Exception("stopAngle not greater than startAngle"); |
513 | 513 | ||
514 | if ((sides == 3 || sides == 4 || sides == 24)) | 514 | if ((sides == 3 || sides == 4 || sides == 24)) |
515 | { | 515 | { |
516 | startAngle *= twoPiInv; | 516 | startAngle *= twoPiInv; |
517 | stopAngle *= twoPiInv; | 517 | stopAngle *= twoPiInv; |
518 | 518 | ||
519 | Angle[] sourceAngles; | 519 | Angle[] sourceAngles; |
520 | if (sides == 3) | 520 | if (sides == 3) |
521 | sourceAngles = angles3; | 521 | sourceAngles = angles3; |
522 | else if (sides == 4) | 522 | else if (sides == 4) |
523 | sourceAngles = angles4; | 523 | sourceAngles = angles4; |
524 | else sourceAngles = angles24; | 524 | else sourceAngles = angles24; |
525 | 525 | ||
526 | int startAngleIndex = (int)(startAngle * sides); | 526 | int startAngleIndex = (int)(startAngle * sides); |
527 | int endAngleIndex = sourceAngles.Length - 1; | 527 | int endAngleIndex = sourceAngles.Length - 1; |
528 | if (stopAngle < 1.0f) | 528 | if (stopAngle < 1.0f) |
529 | endAngleIndex = (int)(stopAngle * sides) + 1; | 529 | endAngleIndex = (int)(stopAngle * sides) + 1; |
530 | if (endAngleIndex == startAngleIndex) | 530 | if (endAngleIndex == startAngleIndex) |
531 | endAngleIndex++; | 531 | endAngleIndex++; |
532 | 532 | ||
533 | for (int angleIndex = startAngleIndex; angleIndex < endAngleIndex + 1; angleIndex++) | 533 | for (int angleIndex = startAngleIndex; angleIndex < endAngleIndex + 1; angleIndex++) |
534 | { | 534 | { |
535 | angles.Add(sourceAngles[angleIndex]); | 535 | angles.Add(sourceAngles[angleIndex]); |
536 | if (sides == 3) | 536 | if (sides == 3) |
537 | normals.Add(normals3[angleIndex]); | 537 | normals.Add(normals3[angleIndex]); |
538 | else if (sides == 4) | 538 | else if (sides == 4) |
539 | normals.Add(normals4[angleIndex]); | 539 | normals.Add(normals4[angleIndex]); |
540 | } | 540 | } |
541 | 541 | ||
542 | if (startAngle > 0.0f) | 542 | if (startAngle > 0.0f) |
543 | angles[0] = interpolatePoints(startAngle, angles[0], angles[1]); | 543 | angles[0] = interpolatePoints(startAngle, angles[0], angles[1]); |
544 | 544 | ||
545 | if (stopAngle < 1.0f) | 545 | if (stopAngle < 1.0f) |
546 | { | 546 | { |
547 | int lastAngleIndex = angles.Count - 1; | 547 | int lastAngleIndex = angles.Count - 1; |
548 | angles[lastAngleIndex] = interpolatePoints(stopAngle, angles[lastAngleIndex - 1], angles[lastAngleIndex]); | 548 | angles[lastAngleIndex] = interpolatePoints(stopAngle, angles[lastAngleIndex - 1], angles[lastAngleIndex]); |
549 | } | 549 | } |
550 | } | 550 | } |
551 | else | 551 | else |
552 | { | 552 | { |
553 | double stepSize = twoPi / sides; | 553 | double stepSize = twoPi / sides; |
554 | 554 | ||
555 | int startStep = (int)(startAngle / stepSize); | 555 | int startStep = (int)(startAngle / stepSize); |
556 | double angle = stepSize * startStep; | 556 | double angle = stepSize * startStep; |
557 | int step = startStep; | 557 | int step = startStep; |
558 | double stopAngleTest = stopAngle; | 558 | double stopAngleTest = stopAngle; |
559 | if (stopAngle < twoPi) | 559 | if (stopAngle < twoPi) |
560 | { | 560 | { |
561 | stopAngleTest = stepSize * ((int)(stopAngle / stepSize) + 1); | 561 | stopAngleTest = stepSize * ((int)(stopAngle / stepSize) + 1); |
562 | if (stopAngleTest < stopAngle) | 562 | if (stopAngleTest < stopAngle) |
563 | stopAngleTest += stepSize; | 563 | stopAngleTest += stepSize; |
564 | if (stopAngleTest > twoPi) | 564 | if (stopAngleTest > twoPi) |
565 | stopAngleTest = twoPi; | 565 | stopAngleTest = twoPi; |
566 | } | 566 | } |
567 | 567 | ||
568 | while (angle <= stopAngleTest) | 568 | while (angle <= stopAngleTest) |
569 | { | 569 | { |
570 | Angle newAngle; | 570 | Angle newAngle; |
571 | newAngle.angle = (float)angle; | 571 | newAngle.angle = (float)angle; |
572 | newAngle.X = (float)System.Math.Cos(angle); | 572 | newAngle.X = (float)System.Math.Cos(angle); |
573 | newAngle.Y = (float)System.Math.Sin(angle); | 573 | newAngle.Y = (float)System.Math.Sin(angle); |
574 | angles.Add(newAngle); | 574 | angles.Add(newAngle); |
575 | step += 1; | 575 | step += 1; |
576 | angle = stepSize * step; | 576 | angle = stepSize * step; |
577 | } | 577 | } |
578 | 578 | ||
579 | if (startAngle > angles[0].angle) | 579 | if (startAngle > angles[0].angle) |
580 | { | 580 | { |
581 | Angle newAngle; | 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)); | 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; | 583 | newAngle.angle = startAngle; |
584 | newAngle.X = iX; | 584 | newAngle.X = iX; |
585 | newAngle.Y = iY; | 585 | newAngle.Y = iY; |
586 | angles[0] = newAngle; | 586 | angles[0] = newAngle; |
587 | } | 587 | } |
588 | 588 | ||
589 | int index = angles.Count - 1; | 589 | int index = angles.Count - 1; |
590 | if (stopAngle < angles[index].angle) | 590 | if (stopAngle < angles[index].angle) |
591 | { | 591 | { |
592 | Angle newAngle; | 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)); | 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; | 594 | newAngle.angle = stopAngle; |
595 | newAngle.X = iX; | 595 | newAngle.X = iX; |
596 | newAngle.Y = iY; | 596 | newAngle.Y = iY; |
597 | angles[index] = newAngle; | 597 | angles[index] = newAngle; |
598 | } | 598 | } |
599 | } | 599 | } |
600 | } | 600 | } |
601 | } | 601 | } |
602 | 602 | ||
603 | /// <summary> | 603 | /// <summary> |
604 | /// generates a profile for extrusion | 604 | /// generates a profile for extrusion |
605 | /// </summary> | 605 | /// </summary> |
606 | internal class Profile | 606 | internal class Profile |
607 | { | 607 | { |
608 | private const float twoPi = 2.0f * (float)Math.PI; | 608 | private const float twoPi = 2.0f * (float)Math.PI; |
609 | 609 | ||
610 | internal string errorMessage = null; | 610 | internal string errorMessage = null; |
611 | 611 | ||
612 | internal List<Coord> coords; | 612 | internal List<Coord> coords; |
613 | internal List<Face> faces; | 613 | internal List<Face> faces; |
614 | internal List<Coord> vertexNormals; | 614 | internal List<Coord> vertexNormals; |
615 | internal List<float> us; | 615 | internal List<float> us; |
616 | internal List<UVCoord> faceUVs; | 616 | internal List<UVCoord> faceUVs; |
617 | internal List<int> faceNumbers; | 617 | internal List<int> faceNumbers; |
618 | 618 | ||
619 | // use these for making individual meshes for each prim face | 619 | // use these for making individual meshes for each prim face |
620 | internal List<int> outerCoordIndices = null; | 620 | internal List<int> outerCoordIndices = null; |
621 | internal List<int> hollowCoordIndices = null; | 621 | internal List<int> hollowCoordIndices = null; |
622 | internal List<int> cut1CoordIndices = null; | 622 | internal List<int> cut1CoordIndices = null; |
623 | internal List<int> cut2CoordIndices = null; | 623 | internal List<int> cut2CoordIndices = null; |
624 | 624 | ||
625 | internal Coord faceNormal = new Coord(0.0f, 0.0f, 1.0f); | 625 | internal Coord faceNormal = new Coord(0.0f, 0.0f, 1.0f); |
626 | internal Coord cutNormal1 = new Coord(); | 626 | internal Coord cutNormal1 = new Coord(); |
627 | internal Coord cutNormal2 = new Coord(); | 627 | internal Coord cutNormal2 = new Coord(); |
628 | 628 | ||
629 | internal int numOuterVerts = 0; | 629 | internal int numOuterVerts = 0; |
630 | internal int numHollowVerts = 0; | 630 | internal int numHollowVerts = 0; |
631 | 631 | ||
632 | internal int outerFaceNumber = -1; | 632 | internal int outerFaceNumber = -1; |
633 | internal int hollowFaceNumber = -1; | 633 | internal int hollowFaceNumber = -1; |
634 | 634 | ||
635 | internal bool calcVertexNormals = false; | 635 | internal bool calcVertexNormals = false; |
636 | internal int bottomFaceNumber = 0; | 636 | internal int bottomFaceNumber = 0; |
637 | internal int numPrimFaces = 0; | 637 | internal int numPrimFaces = 0; |
638 | 638 | ||
639 | internal Profile() | 639 | internal Profile() |
640 | { | 640 | { |
641 | this.coords = new List<Coord>(); | 641 | this.coords = new List<Coord>(); |
642 | this.faces = new List<Face>(); | 642 | this.faces = new List<Face>(); |
643 | this.vertexNormals = new List<Coord>(); | 643 | this.vertexNormals = new List<Coord>(); |
644 | this.us = new List<float>(); | 644 | this.us = new List<float>(); |
645 | this.faceUVs = new List<UVCoord>(); | 645 | this.faceUVs = new List<UVCoord>(); |
646 | this.faceNumbers = new List<int>(); | 646 | this.faceNumbers = new List<int>(); |
647 | } | 647 | } |
648 | 648 | ||
649 | internal Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides, bool createFaces, bool calcVertexNormals) | 649 | internal Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides, bool createFaces, bool calcVertexNormals) |
650 | { | 650 | { |
651 | this.calcVertexNormals = calcVertexNormals; | 651 | this.calcVertexNormals = calcVertexNormals; |
652 | this.coords = new List<Coord>(); | 652 | this.coords = new List<Coord>(); |
653 | this.faces = new List<Face>(); | 653 | this.faces = new List<Face>(); |
654 | this.vertexNormals = new List<Coord>(); | 654 | this.vertexNormals = new List<Coord>(); |
655 | this.us = new List<float>(); | 655 | this.us = new List<float>(); |
656 | this.faceUVs = new List<UVCoord>(); | 656 | this.faceUVs = new List<UVCoord>(); |
657 | this.faceNumbers = new List<int>(); | 657 | this.faceNumbers = new List<int>(); |
658 | 658 | ||
659 | Coord center = new Coord(0.0f, 0.0f, 0.0f); | 659 | Coord center = new Coord(0.0f, 0.0f, 0.0f); |
660 | //bool hasCenter = false; | 660 | //bool hasCenter = false; |
661 | 661 | ||
662 | List<Coord> hollowCoords = new List<Coord>(); | 662 | List<Coord> hollowCoords = new List<Coord>(); |
663 | List<Coord> hollowNormals = new List<Coord>(); | 663 | List<Coord> hollowNormals = new List<Coord>(); |
664 | List<float> hollowUs = new List<float>(); | 664 | List<float> hollowUs = new List<float>(); |
665 | 665 | ||
666 | if (calcVertexNormals) | 666 | if (calcVertexNormals) |
667 | { | 667 | { |
668 | this.outerCoordIndices = new List<int>(); | 668 | this.outerCoordIndices = new List<int>(); |
669 | this.hollowCoordIndices = new List<int>(); | 669 | this.hollowCoordIndices = new List<int>(); |
670 | this.cut1CoordIndices = new List<int>(); | 670 | this.cut1CoordIndices = new List<int>(); |
671 | this.cut2CoordIndices = new List<int>(); | 671 | this.cut2CoordIndices = new List<int>(); |
672 | } | 672 | } |
673 | 673 | ||
674 | bool hasHollow = (hollow > 0.0f); | 674 | bool hasHollow = (hollow > 0.0f); |
675 | 675 | ||
676 | bool hasProfileCut = (profileStart > 0.0f || profileEnd < 1.0f); | 676 | bool hasProfileCut = (profileStart > 0.0f || profileEnd < 1.0f); |
677 | 677 | ||
678 | AngleList angles = new AngleList(); | 678 | AngleList angles = new AngleList(); |
679 | AngleList hollowAngles = new AngleList(); | 679 | AngleList hollowAngles = new AngleList(); |
680 | 680 | ||
681 | float xScale = 0.5f; | 681 | float xScale = 0.5f; |
682 | float yScale = 0.5f; | 682 | float yScale = 0.5f; |
683 | if (sides == 4) // corners of a square are sqrt(2) from center | 683 | if (sides == 4) // corners of a square are sqrt(2) from center |
684 | { | 684 | { |
685 | xScale = 0.707f; | 685 | xScale = 0.707f; |
686 | yScale = 0.707f; | 686 | yScale = 0.707f; |
687 | } | 687 | } |
688 | 688 | ||
689 | float startAngle = profileStart * twoPi; | 689 | float startAngle = profileStart * twoPi; |
690 | float stopAngle = profileEnd * twoPi; | 690 | float stopAngle = profileEnd * twoPi; |
691 | 691 | ||
692 | try { angles.makeAngles(sides, startAngle, stopAngle); } | 692 | try { angles.makeAngles(sides, startAngle, stopAngle); } |
693 | catch (Exception ex) | 693 | catch (Exception ex) |
694 | { | 694 | { |
695 | 695 | ||
696 | errorMessage = "makeAngles failed: Exception: " + ex.ToString() | 696 | errorMessage = "makeAngles failed: Exception: " + ex.ToString() |
697 | + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString(); | 697 | + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString(); |
698 | 698 | ||
699 | return; | 699 | return; |
700 | } | 700 | } |
701 | 701 | ||
702 | this.numOuterVerts = angles.angles.Count; | 702 | this.numOuterVerts = angles.angles.Count; |
703 | 703 | ||
704 | // flag to create as few triangles as possible for 3 or 4 side profile | 704 | // flag to create as few triangles as possible for 3 or 4 side profile |
705 | bool simpleFace = (sides < 5 && !hasHollow && !hasProfileCut); | 705 | bool simpleFace = (sides < 5 && !hasHollow && !hasProfileCut); |
706 | 706 | ||
707 | if (hasHollow) | 707 | if (hasHollow) |
708 | { | 708 | { |
709 | if (sides == hollowSides) | 709 | if (sides == hollowSides) |
710 | hollowAngles = angles; | 710 | hollowAngles = angles; |
711 | else | 711 | else |
712 | { | 712 | { |
713 | try { hollowAngles.makeAngles(hollowSides, startAngle, stopAngle); } | 713 | try { hollowAngles.makeAngles(hollowSides, startAngle, stopAngle); } |
714 | catch (Exception ex) | 714 | catch (Exception ex) |
715 | { | 715 | { |
716 | errorMessage = "makeAngles failed: Exception: " + ex.ToString() | 716 | errorMessage = "makeAngles failed: Exception: " + ex.ToString() |
717 | + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString(); | 717 | + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString(); |
718 | 718 | ||
719 | return; | 719 | return; |
720 | } | 720 | } |
721 | } | 721 | } |
722 | this.numHollowVerts = hollowAngles.angles.Count; | 722 | this.numHollowVerts = hollowAngles.angles.Count; |
723 | } | 723 | } |
724 | else if (!simpleFace) | 724 | else if (!simpleFace) |
725 | { | 725 | { |
726 | this.coords.Add(center); | 726 | this.coords.Add(center); |
727 | //hasCenter = true; | 727 | //hasCenter = true; |
728 | if (this.calcVertexNormals) | 728 | if (this.calcVertexNormals) |
729 | this.vertexNormals.Add(new Coord(0.0f, 0.0f, 1.0f)); | 729 | this.vertexNormals.Add(new Coord(0.0f, 0.0f, 1.0f)); |
730 | this.us.Add(0.0f); | 730 | this.us.Add(0.0f); |
731 | } | 731 | } |
732 | 732 | ||
733 | float z = 0.0f; | 733 | float z = 0.0f; |
734 | 734 | ||
735 | Angle angle; | 735 | Angle angle; |
736 | Coord newVert = new Coord(); | 736 | Coord newVert = new Coord(); |
737 | if (hasHollow && hollowSides != sides) | 737 | if (hasHollow && hollowSides != sides) |
738 | { | 738 | { |
739 | int numHollowAngles = hollowAngles.angles.Count; | 739 | int numHollowAngles = hollowAngles.angles.Count; |
740 | for (int i = 0; i < numHollowAngles; i++) | 740 | for (int i = 0; i < numHollowAngles; i++) |
741 | { | 741 | { |
742 | angle = hollowAngles.angles[i]; | 742 | angle = hollowAngles.angles[i]; |
743 | newVert.X = hollow * xScale * angle.X; | 743 | newVert.X = hollow * xScale * angle.X; |
744 | newVert.Y = hollow * yScale * angle.Y; | 744 | newVert.Y = hollow * yScale * angle.Y; |
745 | newVert.Z = z; | 745 | newVert.Z = z; |
746 | 746 | ||
747 | hollowCoords.Add(newVert); | 747 | hollowCoords.Add(newVert); |
748 | if (this.calcVertexNormals) | 748 | if (this.calcVertexNormals) |
749 | { | 749 | { |
750 | if (hollowSides < 5) | 750 | if (hollowSides < 5) |
751 | hollowNormals.Add(hollowAngles.normals[i].Invert()); | 751 | hollowNormals.Add(hollowAngles.normals[i].Invert()); |
752 | else | 752 | else |
753 | hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f)); | 753 | hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f)); |
754 | 754 | ||
755 | hollowUs.Add(angle.angle * hollow); | 755 | hollowUs.Add(angle.angle * hollow); |
756 | } | 756 | } |
757 | } | 757 | } |
758 | } | 758 | } |
759 | 759 | ||
760 | int index = 0; | 760 | int index = 0; |
761 | int numAngles = angles.angles.Count; | 761 | int numAngles = angles.angles.Count; |
762 | 762 | ||
763 | for (int i = 0; i < numAngles; i++) | 763 | for (int i = 0; i < numAngles; i++) |
764 | { | 764 | { |
765 | angle = angles.angles[i]; | 765 | angle = angles.angles[i]; |
766 | newVert.X = angle.X * xScale; | 766 | newVert.X = angle.X * xScale; |
767 | newVert.Y = angle.Y * yScale; | 767 | newVert.Y = angle.Y * yScale; |
768 | newVert.Z = z; | 768 | newVert.Z = z; |
769 | this.coords.Add(newVert); | 769 | this.coords.Add(newVert); |
770 | if (this.calcVertexNormals) | 770 | if (this.calcVertexNormals) |
771 | { | 771 | { |
772 | this.outerCoordIndices.Add(this.coords.Count - 1); | 772 | this.outerCoordIndices.Add(this.coords.Count - 1); |
773 | 773 | ||
774 | if (sides < 5) | 774 | if (sides < 5) |
775 | { | 775 | { |
776 | this.vertexNormals.Add(angles.normals[i]); | 776 | this.vertexNormals.Add(angles.normals[i]); |
777 | float u = angle.angle; | 777 | float u = angle.angle; |
778 | this.us.Add(u); | 778 | this.us.Add(u); |
779 | } | 779 | } |
780 | else | 780 | else |
781 | { | 781 | { |
782 | this.vertexNormals.Add(new Coord(angle.X, angle.Y, 0.0f)); | 782 | this.vertexNormals.Add(new Coord(angle.X, angle.Y, 0.0f)); |
783 | this.us.Add(angle.angle); | 783 | this.us.Add(angle.angle); |
784 | } | 784 | } |
785 | } | 785 | } |
786 | 786 | ||
787 | if (hasHollow) | 787 | if (hasHollow) |
788 | { | 788 | { |
789 | if (hollowSides == sides) | 789 | if (hollowSides == sides) |
790 | { | 790 | { |
791 | newVert.X *= hollow; | 791 | newVert.X *= hollow; |
792 | newVert.Y *= hollow; | 792 | newVert.Y *= hollow; |
793 | newVert.Z = z; | 793 | newVert.Z = z; |
794 | hollowCoords.Add(newVert); | 794 | hollowCoords.Add(newVert); |
795 | if (this.calcVertexNormals) | 795 | if (this.calcVertexNormals) |
796 | { | 796 | { |
797 | if (sides < 5) | 797 | if (sides < 5) |
798 | { | 798 | { |
799 | hollowNormals.Add(angles.normals[i].Invert()); | 799 | hollowNormals.Add(angles.normals[i].Invert()); |
800 | } | 800 | } |
801 | 801 | ||
802 | else | 802 | else |
803 | hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f)); | 803 | hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f)); |
804 | 804 | ||
805 | hollowUs.Add(angle.angle * hollow); | 805 | hollowUs.Add(angle.angle * hollow); |
806 | } | 806 | } |
807 | } | 807 | } |
808 | } | 808 | } |
809 | else if (!simpleFace && createFaces && angle.angle > 0.0001f) | 809 | else if (!simpleFace && createFaces && angle.angle > 0.0001f) |
810 | { | 810 | { |
811 | Face newFace = new Face(); | 811 | Face newFace = new Face(); |
812 | newFace.v1 = 0; | 812 | newFace.v1 = 0; |
813 | newFace.v2 = index; | 813 | newFace.v2 = index; |
814 | newFace.v3 = index + 1; | 814 | newFace.v3 = index + 1; |
815 | 815 | ||
816 | this.faces.Add(newFace); | 816 | this.faces.Add(newFace); |
817 | } | 817 | } |
818 | index += 1; | 818 | index += 1; |
819 | } | 819 | } |
820 | 820 | ||
821 | if (hasHollow) | 821 | if (hasHollow) |
822 | { | 822 | { |
823 | hollowCoords.Reverse(); | 823 | hollowCoords.Reverse(); |
824 | if (this.calcVertexNormals) | 824 | if (this.calcVertexNormals) |
825 | { | 825 | { |
826 | hollowNormals.Reverse(); | 826 | hollowNormals.Reverse(); |
827 | hollowUs.Reverse(); | 827 | hollowUs.Reverse(); |
828 | } | 828 | } |
829 | 829 | ||
830 | if (createFaces) | 830 | if (createFaces) |
831 | { | 831 | { |
832 | //int numOuterVerts = this.coords.Count; | 832 | //int numOuterVerts = this.coords.Count; |
833 | //numOuterVerts = this.coords.Count; | 833 | //numOuterVerts = this.coords.Count; |
834 | //int numHollowVerts = hollowCoords.Count; | 834 | //int numHollowVerts = hollowCoords.Count; |
835 | int numTotalVerts = this.numOuterVerts + this.numHollowVerts; | 835 | int numTotalVerts = this.numOuterVerts + this.numHollowVerts; |
836 | 836 | ||
837 | if (this.numOuterVerts == this.numHollowVerts) | 837 | if (this.numOuterVerts == this.numHollowVerts) |
838 | { | 838 | { |
839 | Face newFace = new Face(); | 839 | Face newFace = new Face(); |
840 | 840 | ||
841 | for (int coordIndex = 0; coordIndex < this.numOuterVerts - 1; coordIndex++) | 841 | for (int coordIndex = 0; coordIndex < this.numOuterVerts - 1; coordIndex++) |
842 | { | 842 | { |
843 | newFace.v1 = coordIndex; | 843 | newFace.v1 = coordIndex; |
844 | newFace.v2 = coordIndex + 1; | 844 | newFace.v2 = coordIndex + 1; |
845 | newFace.v3 = numTotalVerts - coordIndex - 1; | 845 | newFace.v3 = numTotalVerts - coordIndex - 1; |
846 | this.faces.Add(newFace); | 846 | this.faces.Add(newFace); |
847 | 847 | ||
848 | newFace.v1 = coordIndex + 1; | 848 | newFace.v1 = coordIndex + 1; |
849 | newFace.v2 = numTotalVerts - coordIndex - 2; | 849 | newFace.v2 = numTotalVerts - coordIndex - 2; |
850 | newFace.v3 = numTotalVerts - coordIndex - 1; | 850 | newFace.v3 = numTotalVerts - coordIndex - 1; |
851 | this.faces.Add(newFace); | 851 | this.faces.Add(newFace); |
852 | } | 852 | } |
853 | } | 853 | } |
854 | else | 854 | else |
855 | { | 855 | { |
856 | if (this.numOuterVerts < this.numHollowVerts) | 856 | if (this.numOuterVerts < this.numHollowVerts) |
857 | { | 857 | { |
858 | Face newFace = new Face(); | 858 | Face newFace = new Face(); |
859 | int j = 0; // j is the index for outer vertices | 859 | int j = 0; // j is the index for outer vertices |
860 | int maxJ = this.numOuterVerts - 1; | 860 | int maxJ = this.numOuterVerts - 1; |
861 | for (int i = 0; i < this.numHollowVerts; i++) // i is the index for inner vertices | 861 | for (int i = 0; i < this.numHollowVerts; i++) // i is the index for inner vertices |
862 | { | 862 | { |
863 | if (j < maxJ) | 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) | 864 | if (angles.angles[j + 1].angle - hollowAngles.angles[i].angle < hollowAngles.angles[i].angle - angles.angles[j].angle + 0.000001f) |
865 | { | 865 | { |
866 | newFace.v1 = numTotalVerts - i - 1; | 866 | newFace.v1 = numTotalVerts - i - 1; |
867 | newFace.v2 = j; | 867 | newFace.v2 = j; |
868 | newFace.v3 = j + 1; | 868 | newFace.v3 = j + 1; |
869 | 869 | ||
870 | this.faces.Add(newFace); | 870 | this.faces.Add(newFace); |
871 | j += 1; | 871 | j += 1; |
872 | } | 872 | } |
873 | 873 | ||
874 | newFace.v1 = j; | 874 | newFace.v1 = j; |
875 | newFace.v2 = numTotalVerts - i - 2; | 875 | newFace.v2 = numTotalVerts - i - 2; |
876 | newFace.v3 = numTotalVerts - i - 1; | 876 | newFace.v3 = numTotalVerts - i - 1; |
877 | 877 | ||
878 | this.faces.Add(newFace); | 878 | this.faces.Add(newFace); |
879 | } | 879 | } |
880 | } | 880 | } |
881 | else // numHollowVerts < numOuterVerts | 881 | else // numHollowVerts < numOuterVerts |
882 | { | 882 | { |
883 | Face newFace = new Face(); | 883 | Face newFace = new Face(); |
884 | int j = 0; // j is the index for inner vertices | 884 | int j = 0; // j is the index for inner vertices |
885 | int maxJ = this.numHollowVerts - 1; | 885 | int maxJ = this.numHollowVerts - 1; |
886 | for (int i = 0; i < this.numOuterVerts; i++) | 886 | for (int i = 0; i < this.numOuterVerts; i++) |
887 | { | 887 | { |
888 | if (j < maxJ) | 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) | 889 | if (hollowAngles.angles[j + 1].angle - angles.angles[i].angle < angles.angles[i].angle - hollowAngles.angles[j].angle + 0.000001f) |
890 | { | 890 | { |
891 | newFace.v1 = i; | 891 | newFace.v1 = i; |
892 | newFace.v2 = numTotalVerts - j - 2; | 892 | newFace.v2 = numTotalVerts - j - 2; |
893 | newFace.v3 = numTotalVerts - j - 1; | 893 | newFace.v3 = numTotalVerts - j - 1; |
894 | 894 | ||
895 | this.faces.Add(newFace); | 895 | this.faces.Add(newFace); |
896 | j += 1; | 896 | j += 1; |
897 | } | 897 | } |
898 | 898 | ||
899 | newFace.v1 = numTotalVerts - j - 1; | 899 | newFace.v1 = numTotalVerts - j - 1; |
900 | newFace.v2 = i; | 900 | newFace.v2 = i; |
901 | newFace.v3 = i + 1; | 901 | newFace.v3 = i + 1; |
902 | 902 | ||
903 | this.faces.Add(newFace); | 903 | this.faces.Add(newFace); |
904 | } | 904 | } |
905 | } | 905 | } |
906 | } | 906 | } |
907 | } | 907 | } |
908 | 908 | ||
909 | if (calcVertexNormals) | 909 | if (calcVertexNormals) |
910 | { | 910 | { |
911 | foreach (Coord hc in hollowCoords) | 911 | foreach (Coord hc in hollowCoords) |
912 | { | 912 | { |
913 | this.coords.Add(hc); | 913 | this.coords.Add(hc); |
914 | hollowCoordIndices.Add(this.coords.Count - 1); | 914 | hollowCoordIndices.Add(this.coords.Count - 1); |
915 | } | 915 | } |
916 | } | 916 | } |
917 | else | 917 | else |
918 | this.coords.AddRange(hollowCoords); | 918 | this.coords.AddRange(hollowCoords); |
919 | 919 | ||
920 | if (this.calcVertexNormals) | 920 | if (this.calcVertexNormals) |
921 | { | 921 | { |
922 | this.vertexNormals.AddRange(hollowNormals); | 922 | this.vertexNormals.AddRange(hollowNormals); |
923 | this.us.AddRange(hollowUs); | 923 | this.us.AddRange(hollowUs); |
924 | 924 | ||
925 | } | 925 | } |
926 | } | 926 | } |
927 | 927 | ||
928 | if (simpleFace && createFaces) | 928 | if (simpleFace && createFaces) |
929 | { | 929 | { |
930 | if (sides == 3) | 930 | if (sides == 3) |
931 | this.faces.Add(new Face(0, 1, 2)); | 931 | this.faces.Add(new Face(0, 1, 2)); |
932 | else if (sides == 4) | 932 | else if (sides == 4) |
933 | { | 933 | { |
934 | this.faces.Add(new Face(0, 1, 2)); | 934 | this.faces.Add(new Face(0, 1, 2)); |
935 | this.faces.Add(new Face(0, 2, 3)); | 935 | this.faces.Add(new Face(0, 2, 3)); |
936 | } | 936 | } |
937 | } | 937 | } |
938 | 938 | ||
939 | if (calcVertexNormals && hasProfileCut) | 939 | if (calcVertexNormals && hasProfileCut) |
940 | { | 940 | { |
941 | int lastOuterVertIndex = this.numOuterVerts - 1; | 941 | int lastOuterVertIndex = this.numOuterVerts - 1; |
942 | 942 | ||
943 | if (hasHollow) | 943 | if (hasHollow) |
944 | { | 944 | { |
945 | this.cut1CoordIndices.Add(0); | 945 | this.cut1CoordIndices.Add(0); |
946 | this.cut1CoordIndices.Add(this.coords.Count - 1); | 946 | this.cut1CoordIndices.Add(this.coords.Count - 1); |
947 | 947 | ||
948 | this.cut2CoordIndices.Add(lastOuterVertIndex + 1); | 948 | this.cut2CoordIndices.Add(lastOuterVertIndex + 1); |
949 | this.cut2CoordIndices.Add(lastOuterVertIndex); | 949 | this.cut2CoordIndices.Add(lastOuterVertIndex); |
950 | 950 | ||
951 | this.cutNormal1.X = this.coords[0].Y - this.coords[this.coords.Count - 1].Y; | 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); | 952 | this.cutNormal1.Y = -(this.coords[0].X - this.coords[this.coords.Count - 1].X); |
953 | 953 | ||
954 | this.cutNormal2.X = this.coords[lastOuterVertIndex + 1].Y - this.coords[lastOuterVertIndex].Y; | 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); | 955 | this.cutNormal2.Y = -(this.coords[lastOuterVertIndex + 1].X - this.coords[lastOuterVertIndex].X); |
956 | } | 956 | } |
957 | 957 | ||
958 | else | 958 | else |
959 | { | 959 | { |
960 | this.cut1CoordIndices.Add(0); | 960 | this.cut1CoordIndices.Add(0); |
961 | this.cut1CoordIndices.Add(1); | 961 | this.cut1CoordIndices.Add(1); |
962 | 962 | ||
963 | this.cut2CoordIndices.Add(lastOuterVertIndex); | 963 | this.cut2CoordIndices.Add(lastOuterVertIndex); |
964 | this.cut2CoordIndices.Add(0); | 964 | this.cut2CoordIndices.Add(0); |
965 | 965 | ||
966 | this.cutNormal1.X = this.vertexNormals[1].Y; | 966 | this.cutNormal1.X = this.vertexNormals[1].Y; |
967 | this.cutNormal1.Y = -this.vertexNormals[1].X; | 967 | this.cutNormal1.Y = -this.vertexNormals[1].X; |
968 | 968 | ||
969 | this.cutNormal2.X = -this.vertexNormals[this.vertexNormals.Count - 2].Y; | 969 | this.cutNormal2.X = -this.vertexNormals[this.vertexNormals.Count - 2].Y; |
970 | this.cutNormal2.Y = this.vertexNormals[this.vertexNormals.Count - 2].X; | 970 | this.cutNormal2.Y = this.vertexNormals[this.vertexNormals.Count - 2].X; |
971 | 971 | ||
972 | } | 972 | } |
973 | this.cutNormal1.Normalize(); | 973 | this.cutNormal1.Normalize(); |
974 | this.cutNormal2.Normalize(); | 974 | this.cutNormal2.Normalize(); |
975 | } | 975 | } |
976 | 976 | ||
977 | this.MakeFaceUVs(); | 977 | this.MakeFaceUVs(); |
978 | 978 | ||
979 | hollowCoords = null; | 979 | hollowCoords = null; |
980 | hollowNormals = null; | 980 | hollowNormals = null; |
981 | hollowUs = null; | 981 | hollowUs = null; |
982 | 982 | ||
983 | if (calcVertexNormals) | 983 | if (calcVertexNormals) |
984 | { // calculate prim face numbers | 984 | { // calculate prim face numbers |
985 | 985 | ||
986 | // face number order is top, outer, hollow, bottom, start cut, end cut | 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 | 987 | // I know it's ugly but so is the whole concept of prim face numbers |
988 | 988 | ||
989 | int faceNum = 1; // start with outer faces | 989 | int faceNum = 1; // start with outer faces |
990 | this.outerFaceNumber = faceNum; | 990 | this.outerFaceNumber = faceNum; |
991 | 991 | ||
992 | int startVert = hasProfileCut && !hasHollow ? 1 : 0; | 992 | int startVert = hasProfileCut && !hasHollow ? 1 : 0; |
993 | if (startVert > 0) | 993 | if (startVert > 0) |
994 | this.faceNumbers.Add(-1); | 994 | this.faceNumbers.Add(-1); |
995 | for (int i = 0; i < this.numOuterVerts - 1; i++) | 995 | for (int i = 0; i < this.numOuterVerts - 1; i++) |
996 | //this.faceNumbers.Add(sides < 5 ? faceNum++ : faceNum); | 996 | //this.faceNumbers.Add(sides < 5 ? faceNum++ : faceNum); |
997 | this.faceNumbers.Add(sides < 5 && i < sides ? faceNum++ : faceNum); | 997 | this.faceNumbers.Add(sides < 5 && i < sides ? faceNum++ : faceNum); |
998 | 998 | ||
999 | //if (!hasHollow && !hasProfileCut) | 999 | //if (!hasHollow && !hasProfileCut) |
1000 | // this.bottomFaceNumber = faceNum++; | 1000 | // this.bottomFaceNumber = faceNum++; |
1001 | 1001 | ||
1002 | this.faceNumbers.Add(hasProfileCut ? -1 : faceNum++); | 1002 | this.faceNumbers.Add(hasProfileCut ? -1 : faceNum++); |
1003 | 1003 | ||
1004 | if (sides > 4 && (hasHollow || hasProfileCut)) | 1004 | if (sides > 4 && (hasHollow || hasProfileCut)) |
1005 | faceNum++; | 1005 | faceNum++; |
1006 | 1006 | ||
1007 | if (sides < 5 && (hasHollow || hasProfileCut) && this.numOuterVerts < sides) | 1007 | if (sides < 5 && (hasHollow || hasProfileCut) && this.numOuterVerts < sides) |
1008 | faceNum++; | 1008 | faceNum++; |
1009 | 1009 | ||
1010 | if (hasHollow) | 1010 | if (hasHollow) |
1011 | { | 1011 | { |
1012 | for (int i = 0; i < this.numHollowVerts; i++) | 1012 | for (int i = 0; i < this.numHollowVerts; i++) |
1013 | this.faceNumbers.Add(faceNum); | 1013 | this.faceNumbers.Add(faceNum); |
1014 | 1014 | ||
1015 | this.hollowFaceNumber = faceNum++; | 1015 | this.hollowFaceNumber = faceNum++; |
1016 | } | 1016 | } |
1017 | //if (hasProfileCut || hasHollow) | 1017 | //if (hasProfileCut || hasHollow) |
1018 | // this.bottomFaceNumber = faceNum++; | 1018 | // this.bottomFaceNumber = faceNum++; |
1019 | this.bottomFaceNumber = faceNum++; | 1019 | this.bottomFaceNumber = faceNum++; |
1020 | 1020 | ||
1021 | if (hasHollow && hasProfileCut) | 1021 | if (hasHollow && hasProfileCut) |
1022 | this.faceNumbers.Add(faceNum++); | 1022 | this.faceNumbers.Add(faceNum++); |
1023 | 1023 | ||
1024 | for (int i = 0; i < this.faceNumbers.Count; i++) | 1024 | for (int i = 0; i < this.faceNumbers.Count; i++) |
1025 | if (this.faceNumbers[i] == -1) | 1025 | if (this.faceNumbers[i] == -1) |
1026 | this.faceNumbers[i] = faceNum++; | 1026 | this.faceNumbers[i] = faceNum++; |
1027 | 1027 | ||
1028 | this.numPrimFaces = faceNum; | 1028 | this.numPrimFaces = faceNum; |
1029 | } | 1029 | } |
1030 | 1030 | ||
1031 | } | 1031 | } |
1032 | 1032 | ||
1033 | internal void MakeFaceUVs() | 1033 | internal void MakeFaceUVs() |
1034 | { | 1034 | { |
1035 | this.faceUVs = new List<UVCoord>(); | 1035 | this.faceUVs = new List<UVCoord>(); |
1036 | foreach (Coord c in this.coords) | 1036 | foreach (Coord c in this.coords) |
1037 | this.faceUVs.Add(new UVCoord(0.5f + c.X, 0.5f - c.Y)); | 1037 | this.faceUVs.Add(new UVCoord(0.5f + c.X, 0.5f - c.Y)); |
1038 | } | 1038 | } |
1039 | 1039 | ||
1040 | internal Profile Copy() | 1040 | internal Profile Copy() |
1041 | { | 1041 | { |
1042 | return this.Copy(true); | 1042 | return this.Copy(true); |
1043 | } | 1043 | } |
1044 | 1044 | ||
1045 | internal Profile Copy(bool needFaces) | 1045 | internal Profile Copy(bool needFaces) |
1046 | { | 1046 | { |
1047 | Profile copy = new Profile(); | 1047 | Profile copy = new Profile(); |
1048 | 1048 | ||
1049 | copy.coords.AddRange(this.coords); | 1049 | copy.coords.AddRange(this.coords); |
1050 | copy.faceUVs.AddRange(this.faceUVs); | 1050 | copy.faceUVs.AddRange(this.faceUVs); |
1051 | 1051 | ||
1052 | if (needFaces) | 1052 | if (needFaces) |
1053 | copy.faces.AddRange(this.faces); | 1053 | copy.faces.AddRange(this.faces); |
1054 | if ((copy.calcVertexNormals = this.calcVertexNormals) == true) | 1054 | if ((copy.calcVertexNormals = this.calcVertexNormals) == true) |
1055 | { | 1055 | { |
1056 | copy.vertexNormals.AddRange(this.vertexNormals); | 1056 | copy.vertexNormals.AddRange(this.vertexNormals); |
1057 | copy.faceNormal = this.faceNormal; | 1057 | copy.faceNormal = this.faceNormal; |
1058 | copy.cutNormal1 = this.cutNormal1; | 1058 | copy.cutNormal1 = this.cutNormal1; |
1059 | copy.cutNormal2 = this.cutNormal2; | 1059 | copy.cutNormal2 = this.cutNormal2; |
1060 | copy.us.AddRange(this.us); | 1060 | copy.us.AddRange(this.us); |
1061 | copy.faceNumbers.AddRange(this.faceNumbers); | 1061 | copy.faceNumbers.AddRange(this.faceNumbers); |
1062 | 1062 | ||
1063 | copy.cut1CoordIndices = new List<int>(this.cut1CoordIndices); | 1063 | copy.cut1CoordIndices = new List<int>(this.cut1CoordIndices); |
1064 | copy.cut2CoordIndices = new List<int>(this.cut2CoordIndices); | 1064 | copy.cut2CoordIndices = new List<int>(this.cut2CoordIndices); |
1065 | copy.hollowCoordIndices = new List<int>(this.hollowCoordIndices); | 1065 | copy.hollowCoordIndices = new List<int>(this.hollowCoordIndices); |
1066 | copy.outerCoordIndices = new List<int>(this.outerCoordIndices); | 1066 | copy.outerCoordIndices = new List<int>(this.outerCoordIndices); |
1067 | } | 1067 | } |
1068 | copy.numOuterVerts = this.numOuterVerts; | 1068 | copy.numOuterVerts = this.numOuterVerts; |
1069 | copy.numHollowVerts = this.numHollowVerts; | 1069 | copy.numHollowVerts = this.numHollowVerts; |
1070 | 1070 | ||
1071 | return copy; | 1071 | return copy; |
1072 | } | 1072 | } |
1073 | 1073 | ||
1074 | internal void AddPos(Coord v) | 1074 | internal void AddPos(Coord v) |
1075 | { | 1075 | { |
1076 | this.AddPos(v.X, v.Y, v.Z); | 1076 | this.AddPos(v.X, v.Y, v.Z); |
1077 | } | 1077 | } |
1078 | 1078 | ||
1079 | internal void AddPos(float x, float y, float z) | 1079 | internal void AddPos(float x, float y, float z) |
1080 | { | 1080 | { |
1081 | int i; | 1081 | int i; |
1082 | int numVerts = this.coords.Count; | 1082 | int numVerts = this.coords.Count; |
1083 | Coord vert; | 1083 | Coord vert; |
1084 | 1084 | ||
1085 | for (i = 0; i < numVerts; i++) | 1085 | for (i = 0; i < numVerts; i++) |
1086 | { | 1086 | { |
1087 | vert = this.coords[i]; | 1087 | vert = this.coords[i]; |
1088 | vert.X += x; | 1088 | vert.X += x; |
1089 | vert.Y += y; | 1089 | vert.Y += y; |
1090 | vert.Z += z; | 1090 | vert.Z += z; |
1091 | this.coords[i] = vert; | 1091 | this.coords[i] = vert; |
1092 | } | 1092 | } |
1093 | } | 1093 | } |
1094 | 1094 | ||
1095 | internal void AddRot(Quat q) | 1095 | internal void AddRot(Quat q) |
1096 | { | 1096 | { |
1097 | int i; | 1097 | int i; |
1098 | int numVerts = this.coords.Count; | 1098 | int numVerts = this.coords.Count; |
1099 | 1099 | ||
1100 | for (i = 0; i < numVerts; i++) | 1100 | for (i = 0; i < numVerts; i++) |
1101 | this.coords[i] *= q; | 1101 | this.coords[i] *= q; |
1102 | 1102 | ||
1103 | if (this.calcVertexNormals) | 1103 | if (this.calcVertexNormals) |
1104 | { | 1104 | { |
1105 | int numNormals = this.vertexNormals.Count; | 1105 | int numNormals = this.vertexNormals.Count; |
1106 | for (i = 0; i < numNormals; i++) | 1106 | for (i = 0; i < numNormals; i++) |
1107 | this.vertexNormals[i] *= q; | 1107 | this.vertexNormals[i] *= q; |
1108 | 1108 | ||
1109 | this.faceNormal *= q; | 1109 | this.faceNormal *= q; |
1110 | this.cutNormal1 *= q; | 1110 | this.cutNormal1 *= q; |
1111 | this.cutNormal2 *= q; | 1111 | this.cutNormal2 *= q; |
1112 | 1112 | ||
1113 | } | 1113 | } |
1114 | } | 1114 | } |
1115 | 1115 | ||
1116 | internal void Scale(float x, float y) | 1116 | internal void Scale(float x, float y) |
1117 | { | 1117 | { |
1118 | int i; | 1118 | int i; |
1119 | int numVerts = this.coords.Count; | 1119 | int numVerts = this.coords.Count; |
1120 | Coord vert; | 1120 | Coord vert; |
1121 | 1121 | ||
1122 | for (i = 0; i < numVerts; i++) | 1122 | for (i = 0; i < numVerts; i++) |
1123 | { | 1123 | { |
1124 | vert = this.coords[i]; | 1124 | vert = this.coords[i]; |
1125 | vert.X *= x; | 1125 | vert.X *= x; |
1126 | vert.Y *= y; | 1126 | vert.Y *= y; |
1127 | this.coords[i] = vert; | 1127 | this.coords[i] = vert; |
1128 | } | 1128 | } |
1129 | } | 1129 | } |
1130 | 1130 | ||
1131 | /// <summary> | 1131 | /// <summary> |
1132 | /// Changes order of the vertex indices and negates the center vertex normal. Does not alter vertex normals of radial vertices | 1132 | /// Changes order of the vertex indices and negates the center vertex normal. Does not alter vertex normals of radial vertices |
1133 | /// </summary> | 1133 | /// </summary> |
1134 | internal void FlipNormals() | 1134 | internal void FlipNormals() |
1135 | { | 1135 | { |
1136 | int i; | 1136 | int i; |
1137 | int numFaces = this.faces.Count; | 1137 | int numFaces = this.faces.Count; |
1138 | Face tmpFace; | 1138 | Face tmpFace; |
1139 | int tmp; | 1139 | int tmp; |
1140 | 1140 | ||
1141 | for (i = 0; i < numFaces; i++) | 1141 | for (i = 0; i < numFaces; i++) |
1142 | { | 1142 | { |
1143 | tmpFace = this.faces[i]; | 1143 | tmpFace = this.faces[i]; |
1144 | tmp = tmpFace.v3; | 1144 | tmp = tmpFace.v3; |
1145 | tmpFace.v3 = tmpFace.v1; | 1145 | tmpFace.v3 = tmpFace.v1; |
1146 | tmpFace.v1 = tmp; | 1146 | tmpFace.v1 = tmp; |
1147 | this.faces[i] = tmpFace; | 1147 | this.faces[i] = tmpFace; |
1148 | } | 1148 | } |
1149 | 1149 | ||
1150 | if (this.calcVertexNormals) | 1150 | if (this.calcVertexNormals) |
1151 | { | 1151 | { |
1152 | int normalCount = this.vertexNormals.Count; | 1152 | int normalCount = this.vertexNormals.Count; |
1153 | if (normalCount > 0) | 1153 | if (normalCount > 0) |
1154 | { | 1154 | { |
1155 | Coord n = this.vertexNormals[normalCount - 1]; | 1155 | Coord n = this.vertexNormals[normalCount - 1]; |
1156 | n.Z = -n.Z; | 1156 | n.Z = -n.Z; |
1157 | this.vertexNormals[normalCount - 1] = n; | 1157 | this.vertexNormals[normalCount - 1] = n; |
1158 | } | 1158 | } |
1159 | } | 1159 | } |
1160 | 1160 | ||
1161 | this.faceNormal.X = -this.faceNormal.X; | 1161 | this.faceNormal.X = -this.faceNormal.X; |
1162 | this.faceNormal.Y = -this.faceNormal.Y; | 1162 | this.faceNormal.Y = -this.faceNormal.Y; |
1163 | this.faceNormal.Z = -this.faceNormal.Z; | 1163 | this.faceNormal.Z = -this.faceNormal.Z; |
1164 | 1164 | ||
1165 | int numfaceUVs = this.faceUVs.Count; | 1165 | int numfaceUVs = this.faceUVs.Count; |
1166 | for (i = 0; i < numfaceUVs; i++) | 1166 | for (i = 0; i < numfaceUVs; i++) |
1167 | { | 1167 | { |
1168 | UVCoord uv = this.faceUVs[i]; | 1168 | UVCoord uv = this.faceUVs[i]; |
1169 | uv.V = 1.0f - uv.V; | 1169 | uv.V = 1.0f - uv.V; |
1170 | this.faceUVs[i] = uv; | 1170 | this.faceUVs[i] = uv; |
1171 | } | 1171 | } |
1172 | } | 1172 | } |
1173 | 1173 | ||
1174 | internal void AddValue2FaceVertexIndices(int num) | 1174 | internal void AddValue2FaceVertexIndices(int num) |
1175 | { | 1175 | { |
1176 | int numFaces = this.faces.Count; | 1176 | int numFaces = this.faces.Count; |
1177 | Face tmpFace; | 1177 | Face tmpFace; |
1178 | for (int i = 0; i < numFaces; i++) | 1178 | for (int i = 0; i < numFaces; i++) |
1179 | { | 1179 | { |
1180 | tmpFace = this.faces[i]; | 1180 | tmpFace = this.faces[i]; |
1181 | tmpFace.v1 += num; | 1181 | tmpFace.v1 += num; |
1182 | tmpFace.v2 += num; | 1182 | tmpFace.v2 += num; |
1183 | tmpFace.v3 += num; | 1183 | tmpFace.v3 += num; |
1184 | 1184 | ||
1185 | this.faces[i] = tmpFace; | 1185 | this.faces[i] = tmpFace; |
1186 | } | 1186 | } |
1187 | } | 1187 | } |
1188 | 1188 | ||
1189 | internal void AddValue2FaceNormalIndices(int num) | 1189 | internal void AddValue2FaceNormalIndices(int num) |
1190 | { | 1190 | { |
1191 | if (this.calcVertexNormals) | 1191 | if (this.calcVertexNormals) |
1192 | { | 1192 | { |
1193 | int numFaces = this.faces.Count; | 1193 | int numFaces = this.faces.Count; |
1194 | Face tmpFace; | 1194 | Face tmpFace; |
1195 | for (int i = 0; i < numFaces; i++) | 1195 | for (int i = 0; i < numFaces; i++) |
1196 | { | 1196 | { |
1197 | tmpFace = this.faces[i]; | 1197 | tmpFace = this.faces[i]; |
1198 | tmpFace.n1 += num; | 1198 | tmpFace.n1 += num; |
1199 | tmpFace.n2 += num; | 1199 | tmpFace.n2 += num; |
1200 | tmpFace.n3 += num; | 1200 | tmpFace.n3 += num; |
1201 | 1201 | ||
1202 | this.faces[i] = tmpFace; | 1202 | this.faces[i] = tmpFace; |
1203 | } | 1203 | } |
1204 | } | 1204 | } |
1205 | } | 1205 | } |
1206 | 1206 | ||
1207 | internal void DumpRaw(String path, String name, String title) | 1207 | internal void DumpRaw(String path, String name, String title) |
1208 | { | 1208 | { |
1209 | if (path == null) | 1209 | if (path == null) |
1210 | return; | 1210 | return; |
1211 | String fileName = name + "_" + title + ".raw"; | 1211 | String fileName = name + "_" + title + ".raw"; |
1212 | String completePath = System.IO.Path.Combine(path, fileName); | 1212 | String completePath = System.IO.Path.Combine(path, fileName); |
1213 | StreamWriter sw = new StreamWriter(completePath); | 1213 | StreamWriter sw = new StreamWriter(completePath); |
1214 | 1214 | ||
1215 | for (int i = 0; i < this.faces.Count; i++) | 1215 | for (int i = 0; i < this.faces.Count; i++) |
1216 | { | 1216 | { |
1217 | string s = this.coords[this.faces[i].v1].ToString(); | 1217 | string s = this.coords[this.faces[i].v1].ToString(); |
1218 | s += " " + this.coords[this.faces[i].v2].ToString(); | 1218 | s += " " + this.coords[this.faces[i].v2].ToString(); |
1219 | s += " " + this.coords[this.faces[i].v3].ToString(); | 1219 | s += " " + this.coords[this.faces[i].v3].ToString(); |
1220 | 1220 | ||
1221 | sw.WriteLine(s); | 1221 | sw.WriteLine(s); |
1222 | } | 1222 | } |
1223 | 1223 | ||
1224 | sw.Close(); | 1224 | sw.Close(); |
1225 | } | 1225 | } |
1226 | } | 1226 | } |
1227 | 1227 | ||
1228 | public struct PathNode | 1228 | public struct PathNode |
1229 | { | 1229 | { |
1230 | public Coord position; | 1230 | public Coord position; |
1231 | public Quat rotation; | 1231 | public Quat rotation; |
1232 | public float xScale; | 1232 | public float xScale; |
1233 | public float yScale; | 1233 | public float yScale; |
1234 | public float percentOfPath; | 1234 | public float percentOfPath; |
1235 | } | 1235 | } |
1236 | 1236 | ||
1237 | public enum PathType { Linear = 0, Circular = 1, Flexible = 2 } | 1237 | public enum PathType { Linear = 0, Circular = 1, Flexible = 2 } |
1238 | 1238 | ||
1239 | public class Path | 1239 | public class Path |
1240 | { | 1240 | { |
1241 | public List<PathNode> pathNodes = new List<PathNode>(); | 1241 | public List<PathNode> pathNodes = new List<PathNode>(); |
1242 | 1242 | ||
1243 | public float twistBegin = 0.0f; | 1243 | public float twistBegin = 0.0f; |
1244 | public float twistEnd = 0.0f; | 1244 | public float twistEnd = 0.0f; |
1245 | public float topShearX = 0.0f; | 1245 | public float topShearX = 0.0f; |
1246 | public float topShearY = 0.0f; | 1246 | public float topShearY = 0.0f; |
1247 | public float pathCutBegin = 0.0f; | 1247 | public float pathCutBegin = 0.0f; |
1248 | public float pathCutEnd = 1.0f; | 1248 | public float pathCutEnd = 1.0f; |
1249 | public float dimpleBegin = 0.0f; | 1249 | public float dimpleBegin = 0.0f; |
1250 | public float dimpleEnd = 1.0f; | 1250 | public float dimpleEnd = 1.0f; |
1251 | public float skew = 0.0f; | 1251 | public float skew = 0.0f; |
1252 | public float holeSizeX = 1.0f; // called pathScaleX in pbs | 1252 | public float holeSizeX = 1.0f; // called pathScaleX in pbs |
1253 | public float holeSizeY = 0.25f; | 1253 | public float holeSizeY = 0.25f; |
1254 | public float taperX = 0.0f; | 1254 | public float taperX = 0.0f; |
1255 | public float taperY = 0.0f; | 1255 | public float taperY = 0.0f; |
1256 | public float radius = 0.0f; | 1256 | public float radius = 0.0f; |
1257 | public float revolutions = 1.0f; | 1257 | public float revolutions = 1.0f; |
1258 | public int stepsPerRevolution = 24; | 1258 | public int stepsPerRevolution = 24; |
1259 | 1259 | ||
1260 | private const float twoPi = 2.0f * (float)Math.PI; | 1260 | private const float twoPi = 2.0f * (float)Math.PI; |
1261 | 1261 | ||
1262 | public void Create(PathType pathType, int steps) | 1262 | public void Create(PathType pathType, int steps) |
1263 | { | 1263 | { |
1264 | if (pathType == PathType.Linear || pathType == PathType.Flexible) | 1264 | if (pathType == PathType.Linear || pathType == PathType.Flexible) |
1265 | { | 1265 | { |
1266 | int step = 0; | 1266 | int step = 0; |
1267 | 1267 | ||
1268 | float length = this.pathCutEnd - this.pathCutBegin; | 1268 | float length = this.pathCutEnd - this.pathCutBegin; |
1269 | float twistTotal = twistEnd - twistBegin; | 1269 | float twistTotal = twistEnd - twistBegin; |
1270 | float twistTotalAbs = Math.Abs(twistTotal); | 1270 | float twistTotalAbs = Math.Abs(twistTotal); |
1271 | if (twistTotalAbs > 0.01f) | 1271 | if (twistTotalAbs > 0.01f) |
1272 | steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number | 1272 | steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number |
1273 | 1273 | ||
1274 | float start = -0.5f; | 1274 | float start = -0.5f; |
1275 | float stepSize = length / (float)steps; | 1275 | float stepSize = length / (float)steps; |
1276 | float percentOfPathMultiplier = stepSize; | 1276 | float percentOfPathMultiplier = stepSize; |
1277 | float xOffset = 0.0f; | 1277 | float xOffset = 0.0f; |
1278 | float yOffset = 0.0f; | 1278 | float yOffset = 0.0f; |
1279 | float zOffset = start; | 1279 | float zOffset = start; |
1280 | float xOffsetStepIncrement = this.topShearX / steps; | 1280 | float xOffsetStepIncrement = this.topShearX / steps; |
1281 | float yOffsetStepIncrement = this.topShearY / steps; | 1281 | float yOffsetStepIncrement = this.topShearY / steps; |
1282 | 1282 | ||
1283 | float percentOfPath = this.pathCutBegin; | 1283 | float percentOfPath = this.pathCutBegin; |
1284 | zOffset += percentOfPath; | 1284 | zOffset += percentOfPath; |
1285 | 1285 | ||
1286 | // sanity checks | 1286 | // sanity checks |
1287 | 1287 | ||
1288 | bool done = false; | 1288 | bool done = false; |
1289 | 1289 | ||
1290 | while (!done) | 1290 | while (!done) |
1291 | { | 1291 | { |
1292 | PathNode newNode = new PathNode(); | 1292 | PathNode newNode = new PathNode(); |
1293 | 1293 | ||
1294 | newNode.xScale = 1.0f; | 1294 | newNode.xScale = 1.0f; |
1295 | if (this.taperX == 0.0f) | 1295 | if (this.taperX == 0.0f) |
1296 | newNode.xScale = 1.0f; | 1296 | newNode.xScale = 1.0f; |
1297 | else if (this.taperX > 0.0f) | 1297 | else if (this.taperX > 0.0f) |
1298 | newNode.xScale = 1.0f - percentOfPath * this.taperX; | 1298 | newNode.xScale = 1.0f - percentOfPath * this.taperX; |
1299 | else newNode.xScale = 1.0f + (1.0f - percentOfPath) * this.taperX; | 1299 | else newNode.xScale = 1.0f + (1.0f - percentOfPath) * this.taperX; |
1300 | 1300 | ||
1301 | newNode.yScale = 1.0f; | 1301 | newNode.yScale = 1.0f; |
1302 | if (this.taperY == 0.0f) | 1302 | if (this.taperY == 0.0f) |
1303 | newNode.yScale = 1.0f; | 1303 | newNode.yScale = 1.0f; |
1304 | else if (this.taperY > 0.0f) | 1304 | else if (this.taperY > 0.0f) |
1305 | newNode.yScale = 1.0f - percentOfPath * this.taperY; | 1305 | newNode.yScale = 1.0f - percentOfPath * this.taperY; |
1306 | else newNode.yScale = 1.0f + (1.0f - percentOfPath) * this.taperY; | 1306 | else newNode.yScale = 1.0f + (1.0f - percentOfPath) * this.taperY; |
1307 | 1307 | ||
1308 | float twist = twistBegin + twistTotal * percentOfPath; | 1308 | float twist = twistBegin + twistTotal * percentOfPath; |
1309 | 1309 | ||
1310 | newNode.rotation = new Quat(new Coord(0.0f, 0.0f, 1.0f), twist); | 1310 | newNode.rotation = new Quat(new Coord(0.0f, 0.0f, 1.0f), twist); |
1311 | newNode.position = new Coord(xOffset, yOffset, zOffset); | 1311 | newNode.position = new Coord(xOffset, yOffset, zOffset); |
1312 | newNode.percentOfPath = percentOfPath; | 1312 | newNode.percentOfPath = percentOfPath; |
1313 | 1313 | ||
1314 | pathNodes.Add(newNode); | 1314 | pathNodes.Add(newNode); |
1315 | 1315 | ||
1316 | if (step < steps) | 1316 | if (step < steps) |
1317 | { | 1317 | { |
1318 | step += 1; | 1318 | step += 1; |
1319 | percentOfPath += percentOfPathMultiplier; | 1319 | percentOfPath += percentOfPathMultiplier; |
1320 | xOffset += xOffsetStepIncrement; | 1320 | xOffset += xOffsetStepIncrement; |
1321 | yOffset += yOffsetStepIncrement; | 1321 | yOffset += yOffsetStepIncrement; |
1322 | zOffset += stepSize; | 1322 | zOffset += stepSize; |
1323 | if (percentOfPath > this.pathCutEnd) | 1323 | if (percentOfPath > this.pathCutEnd) |
1324 | done = true; | 1324 | done = true; |
1325 | } | 1325 | } |
1326 | else done = true; | 1326 | else done = true; |
1327 | } | 1327 | } |
1328 | } // end of linear path code | 1328 | } // end of linear path code |
1329 | 1329 | ||
1330 | else // pathType == Circular | 1330 | else // pathType == Circular |
1331 | { | 1331 | { |
1332 | float twistTotal = twistEnd - twistBegin; | 1332 | float twistTotal = twistEnd - twistBegin; |
1333 | 1333 | ||
1334 | // if the profile has a lot of twist, add more layers otherwise the layers may overlap | 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 | 1335 | // and the resulting mesh may be quite inaccurate. This method is arbitrary and doesn't |
1336 | // accurately match the viewer | 1336 | // accurately match the viewer |
1337 | float twistTotalAbs = Math.Abs(twistTotal); | 1337 | float twistTotalAbs = Math.Abs(twistTotal); |
1338 | if (twistTotalAbs > 0.01f) | 1338 | if (twistTotalAbs > 0.01f) |
1339 | { | 1339 | { |
1340 | if (twistTotalAbs > Math.PI * 1.5f) | 1340 | if (twistTotalAbs > Math.PI * 1.5f) |
1341 | steps *= 2; | 1341 | steps *= 2; |
1342 | if (twistTotalAbs > Math.PI * 3.0f) | 1342 | if (twistTotalAbs > Math.PI * 3.0f) |
1343 | steps *= 2; | 1343 | steps *= 2; |
1344 | } | 1344 | } |
1345 | 1345 | ||
1346 | float yPathScale = this.holeSizeY * 0.5f; | 1346 | float yPathScale = this.holeSizeY * 0.5f; |
1347 | float pathLength = this.pathCutEnd - this.pathCutBegin; | 1347 | float pathLength = this.pathCutEnd - this.pathCutBegin; |
1348 | float totalSkew = this.skew * 2.0f * pathLength; | 1348 | float totalSkew = this.skew * 2.0f * pathLength; |
1349 | float skewStart = this.pathCutBegin * 2.0f * this.skew - this.skew; | 1349 | float skewStart = this.pathCutBegin * 2.0f * this.skew - this.skew; |
1350 | float xOffsetTopShearXFactor = this.topShearX * (0.25f + 0.5f * (0.5f - this.holeSizeY)); | 1350 | float xOffsetTopShearXFactor = this.topShearX * (0.25f + 0.5f * (0.5f - this.holeSizeY)); |
1351 | float yShearCompensation = 1.0f + Math.Abs(this.topShearY) * 0.25f; | 1351 | float yShearCompensation = 1.0f + Math.Abs(this.topShearY) * 0.25f; |
1352 | 1352 | ||
1353 | // It's not quite clear what pushY (Y top shear) does, but subtracting it from the start and end | 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 | 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 | 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 | 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 | 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 | 1358 | // the meshes generated with this technique appear nearly identical in shape to the same prims when |
1359 | // displayed by the viewer. | 1359 | // displayed by the viewer. |
1360 | 1360 | ||
1361 | float startAngle = (twoPi * this.pathCutBegin * this.revolutions) - this.topShearY * 0.9f; | 1361 | float startAngle = (twoPi * this.pathCutBegin * this.revolutions) - this.topShearY * 0.9f; |
1362 | float endAngle = (twoPi * this.pathCutEnd * this.revolutions) - this.topShearY * 0.9f; | 1362 | float endAngle = (twoPi * this.pathCutEnd * this.revolutions) - this.topShearY * 0.9f; |
1363 | float stepSize = twoPi / this.stepsPerRevolution; | 1363 | float stepSize = twoPi / this.stepsPerRevolution; |
1364 | 1364 | ||
1365 | int step = (int)(startAngle / stepSize); | 1365 | int step = (int)(startAngle / stepSize); |
1366 | float angle = startAngle; | 1366 | float angle = startAngle; |
1367 | 1367 | ||
1368 | bool done = false; | 1368 | bool done = false; |
1369 | while (!done) // loop through the length of the path and add the layers | 1369 | while (!done) // loop through the length of the path and add the layers |
1370 | { | 1370 | { |
1371 | PathNode newNode = new PathNode(); | 1371 | PathNode newNode = new PathNode(); |
1372 | 1372 | ||
1373 | float xProfileScale = (1.0f - Math.Abs(this.skew)) * this.holeSizeX; | 1373 | float xProfileScale = (1.0f - Math.Abs(this.skew)) * this.holeSizeX; |
1374 | float yProfileScale = this.holeSizeY; | 1374 | float yProfileScale = this.holeSizeY; |
1375 | 1375 | ||
1376 | float percentOfPath = angle / (twoPi * this.revolutions); | 1376 | float percentOfPath = angle / (twoPi * this.revolutions); |
1377 | float percentOfAngles = (angle - startAngle) / (endAngle - startAngle); | 1377 | float percentOfAngles = (angle - startAngle) / (endAngle - startAngle); |
1378 | 1378 | ||
1379 | if (this.taperX > 0.01f) | 1379 | if (this.taperX > 0.01f) |
1380 | xProfileScale *= 1.0f - percentOfPath * this.taperX; | 1380 | xProfileScale *= 1.0f - percentOfPath * this.taperX; |
1381 | else if (this.taperX < -0.01f) | 1381 | else if (this.taperX < -0.01f) |
1382 | xProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperX; | 1382 | xProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperX; |
1383 | 1383 | ||
1384 | if (this.taperY > 0.01f) | 1384 | if (this.taperY > 0.01f) |
1385 | yProfileScale *= 1.0f - percentOfPath * this.taperY; | 1385 | yProfileScale *= 1.0f - percentOfPath * this.taperY; |
1386 | else if (this.taperY < -0.01f) | 1386 | else if (this.taperY < -0.01f) |
1387 | yProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperY; | 1387 | yProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperY; |
1388 | 1388 | ||
1389 | newNode.xScale = xProfileScale; | 1389 | newNode.xScale = xProfileScale; |
1390 | newNode.yScale = yProfileScale; | 1390 | newNode.yScale = yProfileScale; |
1391 | 1391 | ||
1392 | float radiusScale = 1.0f; | 1392 | float radiusScale = 1.0f; |
1393 | if (this.radius > 0.001f) | 1393 | if (this.radius > 0.001f) |
1394 | radiusScale = 1.0f - this.radius * percentOfPath; | 1394 | radiusScale = 1.0f - this.radius * percentOfPath; |
1395 | else if (this.radius < 0.001f) | 1395 | else if (this.radius < 0.001f) |
1396 | radiusScale = 1.0f + this.radius * (1.0f - percentOfPath); | 1396 | radiusScale = 1.0f + this.radius * (1.0f - percentOfPath); |
1397 | 1397 | ||
1398 | float twist = twistBegin + twistTotal * percentOfPath; | 1398 | float twist = twistBegin + twistTotal * percentOfPath; |
1399 | 1399 | ||
1400 | float xOffset = 0.5f * (skewStart + totalSkew * percentOfAngles); | 1400 | float xOffset = 0.5f * (skewStart + totalSkew * percentOfAngles); |
1401 | xOffset += (float)Math.Sin(angle) * xOffsetTopShearXFactor; | 1401 | xOffset += (float)Math.Sin(angle) * xOffsetTopShearXFactor; |
1402 | 1402 | ||
1403 | float yOffset = yShearCompensation * (float)Math.Cos(angle) * (0.5f - yPathScale) * radiusScale; | 1403 | float yOffset = yShearCompensation * (float)Math.Cos(angle) * (0.5f - yPathScale) * radiusScale; |
1404 | 1404 | ||
1405 | float zOffset = (float)Math.Sin(angle + this.topShearY) * (0.5f - yPathScale) * radiusScale; | 1405 | float zOffset = (float)Math.Sin(angle + this.topShearY) * (0.5f - yPathScale) * radiusScale; |
1406 | 1406 | ||
1407 | newNode.position = new Coord(xOffset, yOffset, zOffset); | 1407 | newNode.position = new Coord(xOffset, yOffset, zOffset); |
1408 | 1408 | ||
1409 | // now orient the rotation of the profile layer relative to it's position on the path | 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 | 1410 | // adding taperY to the angle used to generate the quat appears to approximate the viewer |
1411 | 1411 | ||
1412 | newNode.rotation = new Quat(new Coord(1.0f, 0.0f, 0.0f), angle + this.topShearY); | 1412 | newNode.rotation = new Quat(new Coord(1.0f, 0.0f, 0.0f), angle + this.topShearY); |
1413 | 1413 | ||
1414 | // next apply twist rotation to the profile layer | 1414 | // next apply twist rotation to the profile layer |
1415 | if (twistTotal != 0.0f || twistBegin != 0.0f) | 1415 | if (twistTotal != 0.0f || twistBegin != 0.0f) |
1416 | newNode.rotation *= new Quat(new Coord(0.0f, 0.0f, 1.0f), twist); | 1416 | newNode.rotation *= new Quat(new Coord(0.0f, 0.0f, 1.0f), twist); |
1417 | 1417 | ||
1418 | newNode.percentOfPath = percentOfPath; | 1418 | newNode.percentOfPath = percentOfPath; |
1419 | 1419 | ||
1420 | pathNodes.Add(newNode); | 1420 | pathNodes.Add(newNode); |
1421 | 1421 | ||
1422 | // calculate terms for next iteration | 1422 | // calculate terms for next iteration |
1423 | // calculate the angle for the next iteration of the loop | 1423 | // calculate the angle for the next iteration of the loop |
1424 | 1424 | ||
1425 | if (angle >= endAngle - 0.01) | 1425 | if (angle >= endAngle - 0.01) |
1426 | done = true; | 1426 | done = true; |
1427 | else | 1427 | else |
1428 | { | 1428 | { |
1429 | step += 1; | 1429 | step += 1; |
1430 | angle = stepSize * step; | 1430 | angle = stepSize * step; |
1431 | if (angle > endAngle) | 1431 | if (angle > endAngle) |
1432 | angle = endAngle; | 1432 | angle = endAngle; |
1433 | } | 1433 | } |
1434 | } | 1434 | } |
1435 | } | 1435 | } |
1436 | } | 1436 | } |
1437 | } | 1437 | } |
1438 | 1438 | ||
1439 | public class PrimMesh | 1439 | public class PrimMesh |
1440 | { | 1440 | { |
1441 | public string errorMessage = ""; | 1441 | public string errorMessage = ""; |
1442 | private const float twoPi = 2.0f * (float)Math.PI; | 1442 | private const float twoPi = 2.0f * (float)Math.PI; |
1443 | 1443 | ||
1444 | public List<Coord> coords; | 1444 | public List<Coord> coords; |
1445 | public List<Coord> normals; | 1445 | public List<Coord> normals; |
1446 | public List<Face> faces; | 1446 | public List<Face> faces; |
1447 | 1447 | ||
1448 | public List<ViewerFace> viewerFaces; | 1448 | public List<ViewerFace> viewerFaces; |
1449 | 1449 | ||
1450 | private int sides = 4; | 1450 | private int sides = 4; |
1451 | private int hollowSides = 4; | 1451 | private int hollowSides = 4; |
1452 | private float profileStart = 0.0f; | 1452 | private float profileStart = 0.0f; |
1453 | private float profileEnd = 1.0f; | 1453 | private float profileEnd = 1.0f; |
1454 | private float hollow = 0.0f; | 1454 | private float hollow = 0.0f; |
1455 | public int twistBegin = 0; | 1455 | public int twistBegin = 0; |
1456 | public int twistEnd = 0; | 1456 | public int twistEnd = 0; |
1457 | public float topShearX = 0.0f; | 1457 | public float topShearX = 0.0f; |
1458 | public float topShearY = 0.0f; | 1458 | public float topShearY = 0.0f; |
1459 | public float pathCutBegin = 0.0f; | 1459 | public float pathCutBegin = 0.0f; |
1460 | public float pathCutEnd = 1.0f; | 1460 | public float pathCutEnd = 1.0f; |
1461 | public float dimpleBegin = 0.0f; | 1461 | public float dimpleBegin = 0.0f; |
1462 | public float dimpleEnd = 1.0f; | 1462 | public float dimpleEnd = 1.0f; |
1463 | public float skew = 0.0f; | 1463 | public float skew = 0.0f; |
1464 | public float holeSizeX = 1.0f; // called pathScaleX in pbs | 1464 | public float holeSizeX = 1.0f; // called pathScaleX in pbs |
1465 | public float holeSizeY = 0.25f; | 1465 | public float holeSizeY = 0.25f; |
1466 | public float taperX = 0.0f; | 1466 | public float taperX = 0.0f; |
1467 | public float taperY = 0.0f; | 1467 | public float taperY = 0.0f; |
1468 | public float radius = 0.0f; | 1468 | public float radius = 0.0f; |
1469 | public float revolutions = 1.0f; | 1469 | public float revolutions = 1.0f; |
1470 | public int stepsPerRevolution = 24; | 1470 | public int stepsPerRevolution = 24; |
1471 | 1471 | ||
1472 | private int profileOuterFaceNumber = -1; | 1472 | private int profileOuterFaceNumber = -1; |
1473 | private int profileHollowFaceNumber = -1; | 1473 | private int profileHollowFaceNumber = -1; |
1474 | 1474 | ||
1475 | private bool hasProfileCut = false; | 1475 | private bool hasProfileCut = false; |
1476 | private bool hasHollow = false; | 1476 | private bool hasHollow = false; |
1477 | public bool calcVertexNormals = false; | 1477 | public bool calcVertexNormals = false; |
1478 | private bool normalsProcessed = false; | 1478 | private bool normalsProcessed = false; |
1479 | public bool viewerMode = false; | 1479 | public bool viewerMode = false; |
1480 | public bool sphereMode = false; | 1480 | public bool sphereMode = false; |
1481 | 1481 | ||
1482 | public int numPrimFaces = 0; | 1482 | public int numPrimFaces = 0; |
1483 | 1483 | ||
1484 | /// <summary> | 1484 | /// <summary> |
1485 | /// Human readable string representation of the parameters used to create a mesh. | 1485 | /// Human readable string representation of the parameters used to create a mesh. |
1486 | /// </summary> | 1486 | /// </summary> |
1487 | /// <returns></returns> | 1487 | /// <returns></returns> |
1488 | public string ParamsToDisplayString() | 1488 | public string ParamsToDisplayString() |
1489 | { | 1489 | { |
1490 | string s = ""; | 1490 | string s = ""; |
1491 | s += "sides..................: " + this.sides.ToString(); | 1491 | s += "sides..................: " + this.sides.ToString(); |
1492 | s += "\nhollowSides..........: " + this.hollowSides.ToString(); | 1492 | s += "\nhollowSides..........: " + this.hollowSides.ToString(); |
1493 | s += "\nprofileStart.........: " + this.profileStart.ToString(); | 1493 | s += "\nprofileStart.........: " + this.profileStart.ToString(); |
1494 | s += "\nprofileEnd...........: " + this.profileEnd.ToString(); | 1494 | s += "\nprofileEnd...........: " + this.profileEnd.ToString(); |
1495 | s += "\nhollow...............: " + this.hollow.ToString(); | 1495 | s += "\nhollow...............: " + this.hollow.ToString(); |
1496 | s += "\ntwistBegin...........: " + this.twistBegin.ToString(); | 1496 | s += "\ntwistBegin...........: " + this.twistBegin.ToString(); |
1497 | s += "\ntwistEnd.............: " + this.twistEnd.ToString(); | 1497 | s += "\ntwistEnd.............: " + this.twistEnd.ToString(); |
1498 | s += "\ntopShearX............: " + this.topShearX.ToString(); | 1498 | s += "\ntopShearX............: " + this.topShearX.ToString(); |
1499 | s += "\ntopShearY............: " + this.topShearY.ToString(); | 1499 | s += "\ntopShearY............: " + this.topShearY.ToString(); |
1500 | s += "\npathCutBegin.........: " + this.pathCutBegin.ToString(); | 1500 | s += "\npathCutBegin.........: " + this.pathCutBegin.ToString(); |
1501 | s += "\npathCutEnd...........: " + this.pathCutEnd.ToString(); | 1501 | s += "\npathCutEnd...........: " + this.pathCutEnd.ToString(); |
1502 | s += "\ndimpleBegin..........: " + this.dimpleBegin.ToString(); | 1502 | s += "\ndimpleBegin..........: " + this.dimpleBegin.ToString(); |
1503 | s += "\ndimpleEnd............: " + this.dimpleEnd.ToString(); | 1503 | s += "\ndimpleEnd............: " + this.dimpleEnd.ToString(); |
1504 | s += "\nskew.................: " + this.skew.ToString(); | 1504 | s += "\nskew.................: " + this.skew.ToString(); |
1505 | s += "\nholeSizeX............: " + this.holeSizeX.ToString(); | 1505 | s += "\nholeSizeX............: " + this.holeSizeX.ToString(); |
1506 | s += "\nholeSizeY............: " + this.holeSizeY.ToString(); | 1506 | s += "\nholeSizeY............: " + this.holeSizeY.ToString(); |
1507 | s += "\ntaperX...............: " + this.taperX.ToString(); | 1507 | s += "\ntaperX...............: " + this.taperX.ToString(); |
1508 | s += "\ntaperY...............: " + this.taperY.ToString(); | 1508 | s += "\ntaperY...............: " + this.taperY.ToString(); |
1509 | s += "\nradius...............: " + this.radius.ToString(); | 1509 | s += "\nradius...............: " + this.radius.ToString(); |
1510 | s += "\nrevolutions..........: " + this.revolutions.ToString(); | 1510 | s += "\nrevolutions..........: " + this.revolutions.ToString(); |
1511 | s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString(); | 1511 | s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString(); |
1512 | s += "\nsphereMode...........: " + this.sphereMode.ToString(); | 1512 | s += "\nsphereMode...........: " + this.sphereMode.ToString(); |
1513 | s += "\nhasProfileCut........: " + this.hasProfileCut.ToString(); | 1513 | s += "\nhasProfileCut........: " + this.hasProfileCut.ToString(); |
1514 | s += "\nhasHollow............: " + this.hasHollow.ToString(); | 1514 | s += "\nhasHollow............: " + this.hasHollow.ToString(); |
1515 | s += "\nviewerMode...........: " + this.viewerMode.ToString(); | 1515 | s += "\nviewerMode...........: " + this.viewerMode.ToString(); |
1516 | 1516 | ||
1517 | return s; | 1517 | return s; |
1518 | } | 1518 | } |
1519 | 1519 | ||
1520 | public int ProfileOuterFaceNumber | 1520 | public int ProfileOuterFaceNumber |
1521 | { | 1521 | { |
1522 | get { return profileOuterFaceNumber; } | 1522 | get { return profileOuterFaceNumber; } |
1523 | } | 1523 | } |
1524 | 1524 | ||
1525 | public int ProfileHollowFaceNumber | 1525 | public int ProfileHollowFaceNumber |
1526 | { | 1526 | { |
1527 | get { return profileHollowFaceNumber; } | 1527 | get { return profileHollowFaceNumber; } |
1528 | } | 1528 | } |
1529 | 1529 | ||
1530 | public bool HasProfileCut | 1530 | public bool HasProfileCut |
1531 | { | 1531 | { |
1532 | get { return hasProfileCut; } | 1532 | get { return hasProfileCut; } |
1533 | } | 1533 | } |
1534 | 1534 | ||
1535 | public bool HasHollow | 1535 | public bool HasHollow |
1536 | { | 1536 | { |
1537 | get { return hasHollow; } | 1537 | get { return hasHollow; } |
1538 | } | 1538 | } |
1539 | 1539 | ||
1540 | 1540 | ||
1541 | /// <summary> | 1541 | /// <summary> |
1542 | /// Constructs a PrimMesh object and creates the profile for extrusion. | 1542 | /// Constructs a PrimMesh object and creates the profile for extrusion. |
1543 | /// </summary> | 1543 | /// </summary> |
1544 | /// <param name="sides"></param> | 1544 | /// <param name="sides"></param> |
1545 | /// <param name="profileStart"></param> | 1545 | /// <param name="profileStart"></param> |
1546 | /// <param name="profileEnd"></param> | 1546 | /// <param name="profileEnd"></param> |
1547 | /// <param name="hollow"></param> | 1547 | /// <param name="hollow"></param> |
1548 | /// <param name="hollowSides"></param> | 1548 | /// <param name="hollowSides"></param> |
1549 | public PrimMesh(int sides, float profileStart, float profileEnd, float hollow, int hollowSides) | 1549 | public PrimMesh(int sides, float profileStart, float profileEnd, float hollow, int hollowSides) |
1550 | { | 1550 | { |
1551 | this.coords = new List<Coord>(); | 1551 | this.coords = new List<Coord>(); |
1552 | this.faces = new List<Face>(); | 1552 | this.faces = new List<Face>(); |
1553 | 1553 | ||
1554 | this.sides = sides; | 1554 | this.sides = sides; |
1555 | this.profileStart = profileStart; | 1555 | this.profileStart = profileStart; |
1556 | this.profileEnd = profileEnd; | 1556 | this.profileEnd = profileEnd; |
1557 | this.hollow = hollow; | 1557 | this.hollow = hollow; |
1558 | this.hollowSides = hollowSides; | 1558 | this.hollowSides = hollowSides; |
1559 | 1559 | ||
1560 | if (sides < 3) | 1560 | if (sides < 3) |
1561 | this.sides = 3; | 1561 | this.sides = 3; |
1562 | if (hollowSides < 3) | 1562 | if (hollowSides < 3) |
1563 | this.hollowSides = 3; | 1563 | this.hollowSides = 3; |
1564 | if (profileStart < 0.0f) | 1564 | if (profileStart < 0.0f) |
1565 | this.profileStart = 0.0f; | 1565 | this.profileStart = 0.0f; |
1566 | if (profileEnd > 1.0f) | 1566 | if (profileEnd > 1.0f) |
1567 | this.profileEnd = 1.0f; | 1567 | this.profileEnd = 1.0f; |
1568 | if (profileEnd < 0.02f) | 1568 | if (profileEnd < 0.02f) |
1569 | this.profileEnd = 0.02f; | 1569 | this.profileEnd = 0.02f; |
1570 | if (profileStart >= profileEnd) | 1570 | if (profileStart >= profileEnd) |
1571 | this.profileStart = profileEnd - 0.02f; | 1571 | this.profileStart = profileEnd - 0.02f; |
1572 | if (hollow > 0.99f) | 1572 | if (hollow > 0.99f) |
1573 | this.hollow = 0.99f; | 1573 | this.hollow = 0.99f; |
1574 | if (hollow < 0.0f) | 1574 | if (hollow < 0.0f) |
1575 | this.hollow = 0.0f; | 1575 | this.hollow = 0.0f; |
1576 | 1576 | ||
1577 | //if (sphereMode) | 1577 | //if (sphereMode) |
1578 | // this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f; | 1578 | // this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f; |
1579 | //else | 1579 | //else |
1580 | // //this.hasProfileCut = (this.profileStart > 0.0f || this.profileEnd < 1.0f); | 1580 | // //this.hasProfileCut = (this.profileStart > 0.0f || this.profileEnd < 1.0f); |
1581 | // this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f; | 1581 | // this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f; |
1582 | //this.hasHollow = (this.hollow > 0.001f); | 1582 | //this.hasHollow = (this.hollow > 0.001f); |
1583 | } | 1583 | } |
1584 | 1584 | ||
1585 | /// <summary> | 1585 | /// <summary> |
1586 | /// Extrudes a profile along a path. | 1586 | /// Extrudes a profile along a path. |
1587 | /// </summary> | 1587 | /// </summary> |
1588 | public void Extrude(PathType pathType) | 1588 | public void Extrude(PathType pathType) |
1589 | { | 1589 | { |
1590 | bool needEndFaces = false; | 1590 | bool needEndFaces = false; |
1591 | 1591 | ||
1592 | this.coords = new List<Coord>(); | 1592 | this.coords = new List<Coord>(); |
1593 | this.faces = new List<Face>(); | 1593 | this.faces = new List<Face>(); |
1594 | 1594 | ||
1595 | if (this.viewerMode) | 1595 | if (this.viewerMode) |
1596 | { | 1596 | { |
1597 | this.viewerFaces = new List<ViewerFace>(); | 1597 | this.viewerFaces = new List<ViewerFace>(); |
1598 | this.calcVertexNormals = true; | 1598 | this.calcVertexNormals = true; |
1599 | } | 1599 | } |
1600 | 1600 | ||
1601 | if (this.calcVertexNormals) | 1601 | if (this.calcVertexNormals) |
1602 | this.normals = new List<Coord>(); | 1602 | this.normals = new List<Coord>(); |
1603 | 1603 | ||
1604 | int steps = 1; | 1604 | int steps = 1; |
1605 | 1605 | ||
1606 | float length = this.pathCutEnd - this.pathCutBegin; | 1606 | float length = this.pathCutEnd - this.pathCutBegin; |
1607 | normalsProcessed = false; | 1607 | normalsProcessed = false; |
1608 | 1608 | ||
1609 | if (this.viewerMode && this.sides == 3) | 1609 | if (this.viewerMode && this.sides == 3) |
1610 | { | 1610 | { |
1611 | // prisms don't taper well so add some vertical resolution | 1611 | // prisms don't taper well so add some vertical resolution |
1612 | // other prims may benefit from this but just do prisms for now | 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) | 1613 | if (Math.Abs(this.taperX) > 0.01 || Math.Abs(this.taperY) > 0.01) |
1614 | steps = (int)(steps * 4.5 * length); | 1614 | steps = (int)(steps * 4.5 * length); |
1615 | } | 1615 | } |
1616 | 1616 | ||
1617 | if (sphereMode) | 1617 | if (sphereMode) |
1618 | this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f; | 1618 | this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f; |
1619 | else | 1619 | else |
1620 | //this.hasProfileCut = (this.profileStart > 0.0f || this.profileEnd < 1.0f); | 1620 | //this.hasProfileCut = (this.profileStart > 0.0f || this.profileEnd < 1.0f); |
1621 | this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f; | 1621 | this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f; |
1622 | this.hasHollow = (this.hollow > 0.001f); | 1622 | this.hasHollow = (this.hollow > 0.001f); |
1623 | 1623 | ||
1624 | float twistBegin = this.twistBegin / 360.0f * twoPi; | 1624 | float twistBegin = this.twistBegin / 360.0f * twoPi; |
1625 | float twistEnd = this.twistEnd / 360.0f * twoPi; | 1625 | float twistEnd = this.twistEnd / 360.0f * twoPi; |
1626 | float twistTotal = twistEnd - twistBegin; | 1626 | float twistTotal = twistEnd - twistBegin; |
1627 | float twistTotalAbs = Math.Abs(twistTotal); | 1627 | float twistTotalAbs = Math.Abs(twistTotal); |
1628 | if (twistTotalAbs > 0.01f) | 1628 | if (twistTotalAbs > 0.01f) |
1629 | steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number | 1629 | steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number |
1630 | 1630 | ||
1631 | float hollow = this.hollow; | 1631 | float hollow = this.hollow; |
1632 | 1632 | ||
1633 | // sanity checks | 1633 | // sanity checks |
1634 | float initialProfileRot = 0.0f; | 1634 | float initialProfileRot = 0.0f; |
1635 | if (pathType == PathType.Circular) | 1635 | if (pathType == PathType.Circular) |
1636 | { | 1636 | { |
1637 | if (this.sides == 3) | 1637 | if (this.sides == 3) |
1638 | { | 1638 | { |
1639 | initialProfileRot = (float)Math.PI; | 1639 | initialProfileRot = (float)Math.PI; |
1640 | if (this.hollowSides == 4) | 1640 | if (this.hollowSides == 4) |
1641 | { | 1641 | { |
1642 | if (hollow > 0.7f) | 1642 | if (hollow > 0.7f) |
1643 | hollow = 0.7f; | 1643 | hollow = 0.7f; |
1644 | hollow *= 0.707f; | 1644 | hollow *= 0.707f; |
1645 | } | 1645 | } |
1646 | else hollow *= 0.5f; | 1646 | else hollow *= 0.5f; |
1647 | } | 1647 | } |
1648 | else if (this.sides == 4) | 1648 | else if (this.sides == 4) |
1649 | { | 1649 | { |
1650 | initialProfileRot = 0.25f * (float)Math.PI; | 1650 | initialProfileRot = 0.25f * (float)Math.PI; |
1651 | if (this.hollowSides != 4) | 1651 | if (this.hollowSides != 4) |
1652 | hollow *= 0.707f; | 1652 | hollow *= 0.707f; |
1653 | } | 1653 | } |
1654 | else if (this.sides > 4) | 1654 | else if (this.sides > 4) |
1655 | { | 1655 | { |
1656 | initialProfileRot = (float)Math.PI; | 1656 | initialProfileRot = (float)Math.PI; |
1657 | if (this.hollowSides == 4) | 1657 | if (this.hollowSides == 4) |
1658 | { | 1658 | { |
1659 | if (hollow > 0.7f) | 1659 | if (hollow > 0.7f) |
1660 | hollow = 0.7f; | 1660 | hollow = 0.7f; |
1661 | hollow /= 0.7f; | 1661 | hollow /= 0.7f; |
1662 | } | 1662 | } |
1663 | } | 1663 | } |
1664 | } | 1664 | } |
1665 | else | 1665 | else |
1666 | { | 1666 | { |
1667 | if (this.sides == 3) | 1667 | if (this.sides == 3) |
1668 | { | 1668 | { |
1669 | if (this.hollowSides == 4) | 1669 | if (this.hollowSides == 4) |
1670 | { | 1670 | { |
1671 | if (hollow > 0.7f) | 1671 | if (hollow > 0.7f) |
1672 | hollow = 0.7f; | 1672 | hollow = 0.7f; |
1673 | hollow *= 0.707f; | 1673 | hollow *= 0.707f; |
1674 | } | 1674 | } |
1675 | else hollow *= 0.5f; | 1675 | else hollow *= 0.5f; |
1676 | } | 1676 | } |
1677 | else if (this.sides == 4) | 1677 | else if (this.sides == 4) |
1678 | { | 1678 | { |
1679 | initialProfileRot = 1.25f * (float)Math.PI; | 1679 | initialProfileRot = 1.25f * (float)Math.PI; |
1680 | if (this.hollowSides != 4) | 1680 | if (this.hollowSides != 4) |
1681 | hollow *= 0.707f; | 1681 | hollow *= 0.707f; |
1682 | } | 1682 | } |
1683 | else if (this.sides == 24 && this.hollowSides == 4) | 1683 | else if (this.sides == 24 && this.hollowSides == 4) |
1684 | hollow *= 1.414f; | 1684 | hollow *= 1.414f; |
1685 | } | 1685 | } |
1686 | 1686 | ||
1687 | Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides, true, calcVertexNormals); | 1687 | Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides, true, calcVertexNormals); |
1688 | this.errorMessage = profile.errorMessage; | 1688 | this.errorMessage = profile.errorMessage; |
1689 | 1689 | ||
1690 | this.numPrimFaces = profile.numPrimFaces; | 1690 | this.numPrimFaces = profile.numPrimFaces; |
1691 | 1691 | ||
1692 | //profileOuterFaceNumber = profile.faceNumbers[0]; | 1692 | //profileOuterFaceNumber = profile.faceNumbers[0]; |
1693 | //if (!needEndFaces) | 1693 | //if (!needEndFaces) |
1694 | // profileOuterFaceNumber--; | 1694 | // profileOuterFaceNumber--; |
1695 | //profileOuterFaceNumber = needEndFaces ? 1 : 0; | 1695 | //profileOuterFaceNumber = needEndFaces ? 1 : 0; |
1696 | 1696 | ||
1697 | 1697 | ||
1698 | //if (hasHollow) | 1698 | //if (hasHollow) |
1699 | //{ | 1699 | //{ |
1700 | // if (needEndFaces) | 1700 | // if (needEndFaces) |
1701 | // profileHollowFaceNumber = profile.faceNumbers[profile.numOuterVerts + 1]; | 1701 | // profileHollowFaceNumber = profile.faceNumbers[profile.numOuterVerts + 1]; |
1702 | // else | 1702 | // else |
1703 | // profileHollowFaceNumber = profile.faceNumbers[profile.numOuterVerts] - 1; | 1703 | // profileHollowFaceNumber = profile.faceNumbers[profile.numOuterVerts] - 1; |
1704 | //} | 1704 | //} |
1705 | 1705 | ||
1706 | 1706 | ||
1707 | profileOuterFaceNumber = profile.outerFaceNumber; | 1707 | profileOuterFaceNumber = profile.outerFaceNumber; |
1708 | if (!needEndFaces) | 1708 | if (!needEndFaces) |
1709 | profileOuterFaceNumber--; | 1709 | profileOuterFaceNumber--; |
1710 | 1710 | ||
1711 | if (hasHollow) | 1711 | if (hasHollow) |
1712 | { | 1712 | { |
1713 | profileHollowFaceNumber = profile.hollowFaceNumber; | 1713 | profileHollowFaceNumber = profile.hollowFaceNumber; |
1714 | if (!needEndFaces) | 1714 | if (!needEndFaces) |
1715 | profileHollowFaceNumber--; | 1715 | profileHollowFaceNumber--; |
1716 | } | 1716 | } |
1717 | 1717 | ||
1718 | int cut1Vert = -1; | 1718 | int cut1Vert = -1; |
1719 | int cut2Vert = -1; | 1719 | int cut2Vert = -1; |
1720 | if (hasProfileCut) | 1720 | if (hasProfileCut) |
1721 | { | 1721 | { |
1722 | cut1Vert = hasHollow ? profile.coords.Count - 1 : 0; | 1722 | cut1Vert = hasHollow ? profile.coords.Count - 1 : 0; |
1723 | cut2Vert = hasHollow ? profile.numOuterVerts - 1 : profile.numOuterVerts; | 1723 | cut2Vert = hasHollow ? profile.numOuterVerts - 1 : profile.numOuterVerts; |
1724 | } | 1724 | } |
1725 | 1725 | ||
1726 | if (initialProfileRot != 0.0f) | 1726 | if (initialProfileRot != 0.0f) |
1727 | { | 1727 | { |
1728 | profile.AddRot(new Quat(new Coord(0.0f, 0.0f, 1.0f), initialProfileRot)); | 1728 | profile.AddRot(new Quat(new Coord(0.0f, 0.0f, 1.0f), initialProfileRot)); |
1729 | if (viewerMode) | 1729 | if (viewerMode) |
1730 | profile.MakeFaceUVs(); | 1730 | profile.MakeFaceUVs(); |
1731 | } | 1731 | } |
1732 | 1732 | ||
1733 | Coord lastCutNormal1 = new Coord(); | 1733 | Coord lastCutNormal1 = new Coord(); |
1734 | Coord lastCutNormal2 = new Coord(); | 1734 | Coord lastCutNormal2 = new Coord(); |
1735 | float lastV = 1.0f; | 1735 | float lastV = 1.0f; |
1736 | 1736 | ||
1737 | Path path = new Path(); | 1737 | Path path = new Path(); |
1738 | path.twistBegin = twistBegin; | 1738 | path.twistBegin = twistBegin; |
1739 | path.twistEnd = twistEnd; | 1739 | path.twistEnd = twistEnd; |
1740 | path.topShearX = topShearX; | 1740 | path.topShearX = topShearX; |
1741 | path.topShearY = topShearY; | 1741 | path.topShearY = topShearY; |
1742 | path.pathCutBegin = pathCutBegin; | 1742 | path.pathCutBegin = pathCutBegin; |
1743 | path.pathCutEnd = pathCutEnd; | 1743 | path.pathCutEnd = pathCutEnd; |
1744 | path.dimpleBegin = dimpleBegin; | 1744 | path.dimpleBegin = dimpleBegin; |
1745 | path.dimpleEnd = dimpleEnd; | 1745 | path.dimpleEnd = dimpleEnd; |
1746 | path.skew = skew; | 1746 | path.skew = skew; |
1747 | path.holeSizeX = holeSizeX; | 1747 | path.holeSizeX = holeSizeX; |
1748 | path.holeSizeY = holeSizeY; | 1748 | path.holeSizeY = holeSizeY; |
1749 | path.taperX = taperX; | 1749 | path.taperX = taperX; |
1750 | path.taperY = taperY; | 1750 | path.taperY = taperY; |
1751 | path.radius = radius; | 1751 | path.radius = radius; |
1752 | path.revolutions = revolutions; | 1752 | path.revolutions = revolutions; |
1753 | path.stepsPerRevolution = stepsPerRevolution; | 1753 | path.stepsPerRevolution = stepsPerRevolution; |
1754 | 1754 | ||
1755 | path.Create(pathType, steps); | 1755 | path.Create(pathType, steps); |
1756 | 1756 | ||
1757 | 1757 | ||
1758 | if (pathType == PathType.Circular) | 1758 | if (pathType == PathType.Circular) |
1759 | { | 1759 | { |
1760 | needEndFaces = false; | 1760 | needEndFaces = false; |
1761 | if (this.pathCutBegin != 0.0f || this.pathCutEnd != 1.0f) | 1761 | if (this.pathCutBegin != 0.0f || this.pathCutEnd != 1.0f) |
1762 | needEndFaces = true; | 1762 | needEndFaces = true; |
1763 | else if (this.taperX != 0.0f || this.taperY != 0.0f) | 1763 | else if (this.taperX != 0.0f || this.taperY != 0.0f) |
1764 | needEndFaces = true; | 1764 | needEndFaces = true; |
1765 | else if (this.skew != 0.0f) | 1765 | else if (this.skew != 0.0f) |
1766 | needEndFaces = true; | 1766 | needEndFaces = true; |
1767 | else if (twistTotal != 0.0f) | 1767 | else if (twistTotal != 0.0f) |
1768 | needEndFaces = true; | 1768 | needEndFaces = true; |
1769 | else if (this.radius != 0.0f) | 1769 | else if (this.radius != 0.0f) |
1770 | needEndFaces = true; | 1770 | needEndFaces = true; |
1771 | } | 1771 | } |
1772 | else needEndFaces = true; | 1772 | else needEndFaces = true; |
1773 | 1773 | ||
1774 | for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++) | 1774 | for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++) |
1775 | { | 1775 | { |
1776 | PathNode node = path.pathNodes[nodeIndex]; | 1776 | PathNode node = path.pathNodes[nodeIndex]; |
1777 | Profile newLayer = profile.Copy(); | 1777 | Profile newLayer = profile.Copy(); |
1778 | newLayer.Scale(node.xScale, node.yScale); | 1778 | newLayer.Scale(node.xScale, node.yScale); |
1779 | 1779 | ||
1780 | newLayer.AddRot(node.rotation); | 1780 | newLayer.AddRot(node.rotation); |
1781 | newLayer.AddPos(node.position); | 1781 | newLayer.AddPos(node.position); |
1782 | 1782 | ||
1783 | if (needEndFaces && nodeIndex == 0) | 1783 | if (needEndFaces && nodeIndex == 0) |
1784 | { | 1784 | { |
1785 | newLayer.FlipNormals(); | 1785 | newLayer.FlipNormals(); |
1786 | 1786 | ||
1787 | // add the top faces to the viewerFaces list here | 1787 | // add the top faces to the viewerFaces list here |
1788 | if (this.viewerMode) | 1788 | if (this.viewerMode) |
1789 | { | 1789 | { |
1790 | Coord faceNormal = newLayer.faceNormal; | 1790 | Coord faceNormal = newLayer.faceNormal; |
1791 | ViewerFace newViewerFace = new ViewerFace(profile.bottomFaceNumber); | 1791 | ViewerFace newViewerFace = new ViewerFace(profile.bottomFaceNumber); |
1792 | int numFaces = newLayer.faces.Count; | 1792 | int numFaces = newLayer.faces.Count; |
1793 | List<Face> faces = newLayer.faces; | 1793 | List<Face> faces = newLayer.faces; |
1794 | 1794 | ||
1795 | for (int i = 0; i < numFaces; i++) | 1795 | for (int i = 0; i < numFaces; i++) |
1796 | { | 1796 | { |
1797 | Face face = faces[i]; | 1797 | Face face = faces[i]; |
1798 | newViewerFace.v1 = newLayer.coords[face.v1]; | 1798 | newViewerFace.v1 = newLayer.coords[face.v1]; |
1799 | newViewerFace.v2 = newLayer.coords[face.v2]; | 1799 | newViewerFace.v2 = newLayer.coords[face.v2]; |
1800 | newViewerFace.v3 = newLayer.coords[face.v3]; | 1800 | newViewerFace.v3 = newLayer.coords[face.v3]; |
1801 | 1801 | ||
1802 | newViewerFace.coordIndex1 = face.v1; | 1802 | newViewerFace.coordIndex1 = face.v1; |
1803 | newViewerFace.coordIndex2 = face.v2; | 1803 | newViewerFace.coordIndex2 = face.v2; |
1804 | newViewerFace.coordIndex3 = face.v3; | 1804 | newViewerFace.coordIndex3 = face.v3; |
1805 | 1805 | ||
1806 | newViewerFace.n1 = faceNormal; | 1806 | newViewerFace.n1 = faceNormal; |
1807 | newViewerFace.n2 = faceNormal; | 1807 | newViewerFace.n2 = faceNormal; |
1808 | newViewerFace.n3 = faceNormal; | 1808 | newViewerFace.n3 = faceNormal; |
1809 | 1809 | ||
1810 | newViewerFace.uv1 = newLayer.faceUVs[face.v1]; | 1810 | newViewerFace.uv1 = newLayer.faceUVs[face.v1]; |
1811 | newViewerFace.uv2 = newLayer.faceUVs[face.v2]; | 1811 | newViewerFace.uv2 = newLayer.faceUVs[face.v2]; |
1812 | newViewerFace.uv3 = newLayer.faceUVs[face.v3]; | 1812 | newViewerFace.uv3 = newLayer.faceUVs[face.v3]; |
1813 | 1813 | ||
1814 | this.viewerFaces.Add(newViewerFace); | 1814 | this.viewerFaces.Add(newViewerFace); |
1815 | } | 1815 | } |
1816 | } | 1816 | } |
1817 | } // if (nodeIndex == 0) | 1817 | } // if (nodeIndex == 0) |
1818 | 1818 | ||
1819 | // append this layer | 1819 | // append this layer |
1820 | 1820 | ||
1821 | int coordsLen = this.coords.Count; | 1821 | int coordsLen = this.coords.Count; |
1822 | newLayer.AddValue2FaceVertexIndices(coordsLen); | 1822 | newLayer.AddValue2FaceVertexIndices(coordsLen); |
1823 | 1823 | ||
1824 | this.coords.AddRange(newLayer.coords); | 1824 | this.coords.AddRange(newLayer.coords); |
1825 | 1825 | ||
1826 | if (this.calcVertexNormals) | 1826 | if (this.calcVertexNormals) |
1827 | { | 1827 | { |
1828 | newLayer.AddValue2FaceNormalIndices(this.normals.Count); | 1828 | newLayer.AddValue2FaceNormalIndices(this.normals.Count); |
1829 | this.normals.AddRange(newLayer.vertexNormals); | 1829 | this.normals.AddRange(newLayer.vertexNormals); |
1830 | } | 1830 | } |
1831 | 1831 | ||
1832 | if (node.percentOfPath < this.pathCutBegin + 0.01f || node.percentOfPath > this.pathCutEnd - 0.01f) | 1832 | if (node.percentOfPath < this.pathCutBegin + 0.01f || node.percentOfPath > this.pathCutEnd - 0.01f) |
1833 | this.faces.AddRange(newLayer.faces); | 1833 | this.faces.AddRange(newLayer.faces); |
1834 | 1834 | ||
1835 | // fill faces between layers | 1835 | // fill faces between layers |
1836 | 1836 | ||
1837 | int numVerts = newLayer.coords.Count; | 1837 | int numVerts = newLayer.coords.Count; |
1838 | Face newFace = new Face(); | 1838 | Face newFace = new Face(); |
1839 | 1839 | ||
1840 | if (nodeIndex > 0) | 1840 | if (nodeIndex > 0) |
1841 | { | 1841 | { |
1842 | int startVert = coordsLen + 1; | 1842 | int startVert = coordsLen + 1; |
1843 | int endVert = this.coords.Count; | 1843 | int endVert = this.coords.Count; |
1844 | 1844 | ||
1845 | if (sides < 5 || this.hasProfileCut || this.hasHollow) | 1845 | if (sides < 5 || this.hasProfileCut || this.hasHollow) |
1846 | startVert--; | 1846 | startVert--; |
1847 | 1847 | ||
1848 | for (int i = startVert; i < endVert; i++) | 1848 | for (int i = startVert; i < endVert; i++) |
1849 | { | 1849 | { |
1850 | int iNext = i + 1; | 1850 | int iNext = i + 1; |
1851 | if (i == endVert - 1) | 1851 | if (i == endVert - 1) |
1852 | iNext = startVert; | 1852 | iNext = startVert; |
1853 | 1853 | ||
1854 | int whichVert = i - startVert; | 1854 | int whichVert = i - startVert; |
1855 | 1855 | ||
1856 | newFace.v1 = i; | 1856 | newFace.v1 = i; |
1857 | newFace.v2 = i - numVerts; | 1857 | newFace.v2 = i - numVerts; |
1858 | newFace.v3 = iNext - numVerts; | 1858 | newFace.v3 = iNext - numVerts; |
1859 | this.faces.Add(newFace); | 1859 | this.faces.Add(newFace); |
1860 | 1860 | ||
1861 | newFace.v2 = iNext - numVerts; | 1861 | newFace.v2 = iNext - numVerts; |
1862 | newFace.v3 = iNext; | 1862 | newFace.v3 = iNext; |
1863 | this.faces.Add(newFace); | 1863 | this.faces.Add(newFace); |
1864 | 1864 | ||
1865 | if (this.viewerMode) | 1865 | if (this.viewerMode) |
1866 | { | 1866 | { |
1867 | // add the side faces to the list of viewerFaces here | 1867 | // add the side faces to the list of viewerFaces here |
1868 | 1868 | ||
1869 | int primFaceNum = profile.faceNumbers[whichVert]; | 1869 | int primFaceNum = profile.faceNumbers[whichVert]; |
1870 | if (!needEndFaces) | 1870 | if (!needEndFaces) |
1871 | primFaceNum -= 1; | 1871 | primFaceNum -= 1; |
1872 | 1872 | ||
1873 | ViewerFace newViewerFace1 = new ViewerFace(primFaceNum); | 1873 | ViewerFace newViewerFace1 = new ViewerFace(primFaceNum); |
1874 | ViewerFace newViewerFace2 = new ViewerFace(primFaceNum); | 1874 | ViewerFace newViewerFace2 = new ViewerFace(primFaceNum); |
1875 | 1875 | ||
1876 | float u1 = newLayer.us[whichVert]; | 1876 | float u1 = newLayer.us[whichVert]; |
1877 | float u2 = 1.0f; | 1877 | float u2 = 1.0f; |
1878 | if (whichVert < newLayer.us.Count - 1) | 1878 | if (whichVert < newLayer.us.Count - 1) |
1879 | u2 = newLayer.us[whichVert + 1]; | 1879 | u2 = newLayer.us[whichVert + 1]; |
1880 | 1880 | ||
1881 | if (whichVert == cut1Vert || whichVert == cut2Vert) | 1881 | if (whichVert == cut1Vert || whichVert == cut2Vert) |
1882 | { | 1882 | { |
1883 | u1 = 0.0f; | 1883 | u1 = 0.0f; |
1884 | u2 = 1.0f; | 1884 | u2 = 1.0f; |
1885 | } | 1885 | } |
1886 | else if (sides < 5) | 1886 | else if (sides < 5) |
1887 | { | 1887 | { |
1888 | if (whichVert < profile.numOuterVerts) | 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 | 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 | 1890 | // to reflect the entire texture width |
1891 | u1 *= sides; | 1891 | u1 *= sides; |
1892 | u2 *= sides; | 1892 | u2 *= sides; |
1893 | u2 -= (int)u1; | 1893 | u2 -= (int)u1; |
1894 | u1 -= (int)u1; | 1894 | u1 -= (int)u1; |
1895 | if (u2 < 0.1f) | 1895 | if (u2 < 0.1f) |
1896 | u2 = 1.0f; | 1896 | u2 = 1.0f; |
1897 | //this.profileOuterFaceNumber = primFaceNum; | 1897 | //this.profileOuterFaceNumber = primFaceNum; |
1898 | } | 1898 | } |
1899 | else if (whichVert > profile.coords.Count - profile.numHollowVerts - 1) | 1899 | else if (whichVert > profile.coords.Count - profile.numHollowVerts - 1) |
1900 | { | 1900 | { |
1901 | u1 *= 2.0f; | 1901 | u1 *= 2.0f; |
1902 | u2 *= 2.0f; | 1902 | u2 *= 2.0f; |
1903 | //this.profileHollowFaceNumber = primFaceNum; | 1903 | //this.profileHollowFaceNumber = primFaceNum; |
1904 | } | 1904 | } |
1905 | } | 1905 | } |
1906 | 1906 | ||
1907 | newViewerFace1.uv1.U = u1; | 1907 | newViewerFace1.uv1.U = u1; |
1908 | newViewerFace1.uv2.U = u1; | 1908 | newViewerFace1.uv2.U = u1; |
1909 | newViewerFace1.uv3.U = u2; | 1909 | newViewerFace1.uv3.U = u2; |
1910 | 1910 | ||
1911 | newViewerFace1.uv1.V = 1.0f - node.percentOfPath; | 1911 | newViewerFace1.uv1.V = 1.0f - node.percentOfPath; |
1912 | newViewerFace1.uv2.V = lastV; | 1912 | newViewerFace1.uv2.V = lastV; |
1913 | newViewerFace1.uv3.V = lastV; | 1913 | newViewerFace1.uv3.V = lastV; |
1914 | 1914 | ||
1915 | newViewerFace2.uv1.U = u1; | 1915 | newViewerFace2.uv1.U = u1; |
1916 | newViewerFace2.uv2.U = u2; | 1916 | newViewerFace2.uv2.U = u2; |
1917 | newViewerFace2.uv3.U = u2; | 1917 | newViewerFace2.uv3.U = u2; |
1918 | 1918 | ||
1919 | newViewerFace2.uv1.V = 1.0f - node.percentOfPath; | 1919 | newViewerFace2.uv1.V = 1.0f - node.percentOfPath; |
1920 | newViewerFace2.uv2.V = lastV; | 1920 | newViewerFace2.uv2.V = lastV; |
1921 | newViewerFace2.uv3.V = 1.0f - node.percentOfPath; | 1921 | newViewerFace2.uv3.V = 1.0f - node.percentOfPath; |
1922 | 1922 | ||
1923 | newViewerFace1.v1 = this.coords[i]; | 1923 | newViewerFace1.v1 = this.coords[i]; |
1924 | newViewerFace1.v2 = this.coords[i - numVerts]; | 1924 | newViewerFace1.v2 = this.coords[i - numVerts]; |
1925 | newViewerFace1.v3 = this.coords[iNext - numVerts]; | 1925 | newViewerFace1.v3 = this.coords[iNext - numVerts]; |
1926 | 1926 | ||
1927 | newViewerFace2.v1 = this.coords[i]; | 1927 | newViewerFace2.v1 = this.coords[i]; |
1928 | newViewerFace2.v2 = this.coords[iNext - numVerts]; | 1928 | newViewerFace2.v2 = this.coords[iNext - numVerts]; |
1929 | newViewerFace2.v3 = this.coords[iNext]; | 1929 | newViewerFace2.v3 = this.coords[iNext]; |
1930 | 1930 | ||
1931 | newViewerFace1.coordIndex1 = i; | 1931 | newViewerFace1.coordIndex1 = i; |
1932 | newViewerFace1.coordIndex2 = i - numVerts; | 1932 | newViewerFace1.coordIndex2 = i - numVerts; |
1933 | newViewerFace1.coordIndex3 = iNext - numVerts; | 1933 | newViewerFace1.coordIndex3 = iNext - numVerts; |
1934 | 1934 | ||
1935 | newViewerFace2.coordIndex1 = i; | 1935 | newViewerFace2.coordIndex1 = i; |
1936 | newViewerFace2.coordIndex2 = iNext - numVerts; | 1936 | newViewerFace2.coordIndex2 = iNext - numVerts; |
1937 | newViewerFace2.coordIndex3 = iNext; | 1937 | newViewerFace2.coordIndex3 = iNext; |
1938 | 1938 | ||
1939 | // profile cut faces | 1939 | // profile cut faces |
1940 | if (whichVert == cut1Vert) | 1940 | if (whichVert == cut1Vert) |
1941 | { | 1941 | { |
1942 | newViewerFace1.n1 = newLayer.cutNormal1; | 1942 | newViewerFace1.n1 = newLayer.cutNormal1; |
1943 | newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal1; | 1943 | newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal1; |
1944 | 1944 | ||
1945 | newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal1; | 1945 | newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal1; |
1946 | newViewerFace2.n2 = lastCutNormal1; | 1946 | newViewerFace2.n2 = lastCutNormal1; |
1947 | } | 1947 | } |
1948 | else if (whichVert == cut2Vert) | 1948 | else if (whichVert == cut2Vert) |
1949 | { | 1949 | { |
1950 | newViewerFace1.n1 = newLayer.cutNormal2; | 1950 | newViewerFace1.n1 = newLayer.cutNormal2; |
1951 | newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal2; | 1951 | newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal2; |
1952 | 1952 | ||
1953 | newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal2; | 1953 | newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal2; |
1954 | newViewerFace2.n2 = lastCutNormal2; | 1954 | newViewerFace2.n2 = lastCutNormal2; |
1955 | } | 1955 | } |
1956 | 1956 | ||
1957 | else // outer and hollow faces | 1957 | else // outer and hollow faces |
1958 | { | 1958 | { |
1959 | if ((sides < 5 && whichVert < newLayer.numOuterVerts) || (hollowSides < 5 && whichVert >= newLayer.numOuterVerts)) | 1959 | if ((sides < 5 && whichVert < newLayer.numOuterVerts) || (hollowSides < 5 && whichVert >= newLayer.numOuterVerts)) |
1960 | { // looks terrible when path is twisted... need vertex normals here | 1960 | { // looks terrible when path is twisted... need vertex normals here |
1961 | newViewerFace1.CalcSurfaceNormal(); | 1961 | newViewerFace1.CalcSurfaceNormal(); |
1962 | newViewerFace2.CalcSurfaceNormal(); | 1962 | newViewerFace2.CalcSurfaceNormal(); |
1963 | } | 1963 | } |
1964 | else | 1964 | else |
1965 | { | 1965 | { |
1966 | newViewerFace1.n1 = this.normals[i]; | 1966 | newViewerFace1.n1 = this.normals[i]; |
1967 | newViewerFace1.n2 = this.normals[i - numVerts]; | 1967 | newViewerFace1.n2 = this.normals[i - numVerts]; |
1968 | newViewerFace1.n3 = this.normals[iNext - numVerts]; | 1968 | newViewerFace1.n3 = this.normals[iNext - numVerts]; |
1969 | 1969 | ||
1970 | newViewerFace2.n1 = this.normals[i]; | 1970 | newViewerFace2.n1 = this.normals[i]; |
1971 | newViewerFace2.n2 = this.normals[iNext - numVerts]; | 1971 | newViewerFace2.n2 = this.normals[iNext - numVerts]; |
1972 | newViewerFace2.n3 = this.normals[iNext]; | 1972 | newViewerFace2.n3 = this.normals[iNext]; |
1973 | } | 1973 | } |
1974 | } | 1974 | } |
1975 | 1975 | ||
1976 | this.viewerFaces.Add(newViewerFace1); | 1976 | this.viewerFaces.Add(newViewerFace1); |
1977 | this.viewerFaces.Add(newViewerFace2); | 1977 | this.viewerFaces.Add(newViewerFace2); |
1978 | 1978 | ||
1979 | } | 1979 | } |
1980 | } | 1980 | } |
1981 | } | 1981 | } |
1982 | 1982 | ||
1983 | lastCutNormal1 = newLayer.cutNormal1; | 1983 | lastCutNormal1 = newLayer.cutNormal1; |
1984 | lastCutNormal2 = newLayer.cutNormal2; | 1984 | lastCutNormal2 = newLayer.cutNormal2; |
1985 | lastV = 1.0f - node.percentOfPath; | 1985 | lastV = 1.0f - node.percentOfPath; |
1986 | 1986 | ||
1987 | if (needEndFaces && nodeIndex == path.pathNodes.Count - 1 && viewerMode) | 1987 | if (needEndFaces && nodeIndex == path.pathNodes.Count - 1 && viewerMode) |
1988 | { | 1988 | { |
1989 | // add the top faces to the viewerFaces list here | 1989 | // add the top faces to the viewerFaces list here |
1990 | Coord faceNormal = newLayer.faceNormal; | 1990 | Coord faceNormal = newLayer.faceNormal; |
1991 | ViewerFace newViewerFace = new ViewerFace(); | 1991 | ViewerFace newViewerFace = new ViewerFace(); |
1992 | newViewerFace.primFaceNumber = 0; | 1992 | newViewerFace.primFaceNumber = 0; |
1993 | int numFaces = newLayer.faces.Count; | 1993 | int numFaces = newLayer.faces.Count; |
1994 | List<Face> faces = newLayer.faces; | 1994 | List<Face> faces = newLayer.faces; |
1995 | 1995 | ||
1996 | for (int i = 0; i < numFaces; i++) | 1996 | for (int i = 0; i < numFaces; i++) |
1997 | { | 1997 | { |
1998 | Face face = faces[i]; | 1998 | Face face = faces[i]; |
1999 | newViewerFace.v1 = newLayer.coords[face.v1 - coordsLen]; | 1999 | newViewerFace.v1 = newLayer.coords[face.v1 - coordsLen]; |
2000 | newViewerFace.v2 = newLayer.coords[face.v2 - coordsLen]; | 2000 | newViewerFace.v2 = newLayer.coords[face.v2 - coordsLen]; |
2001 | newViewerFace.v3 = newLayer.coords[face.v3 - coordsLen]; | 2001 | newViewerFace.v3 = newLayer.coords[face.v3 - coordsLen]; |
2002 | 2002 | ||
2003 | newViewerFace.coordIndex1 = face.v1 - coordsLen; | 2003 | newViewerFace.coordIndex1 = face.v1 - coordsLen; |
2004 | newViewerFace.coordIndex2 = face.v2 - coordsLen; | 2004 | newViewerFace.coordIndex2 = face.v2 - coordsLen; |
2005 | newViewerFace.coordIndex3 = face.v3 - coordsLen; | 2005 | newViewerFace.coordIndex3 = face.v3 - coordsLen; |
2006 | 2006 | ||
2007 | newViewerFace.n1 = faceNormal; | 2007 | newViewerFace.n1 = faceNormal; |
2008 | newViewerFace.n2 = faceNormal; | 2008 | newViewerFace.n2 = faceNormal; |
2009 | newViewerFace.n3 = faceNormal; | 2009 | newViewerFace.n3 = faceNormal; |
2010 | 2010 | ||
2011 | newViewerFace.uv1 = newLayer.faceUVs[face.v1 - coordsLen]; | 2011 | newViewerFace.uv1 = newLayer.faceUVs[face.v1 - coordsLen]; |
2012 | newViewerFace.uv2 = newLayer.faceUVs[face.v2 - coordsLen]; | 2012 | newViewerFace.uv2 = newLayer.faceUVs[face.v2 - coordsLen]; |
2013 | newViewerFace.uv3 = newLayer.faceUVs[face.v3 - coordsLen]; | 2013 | newViewerFace.uv3 = newLayer.faceUVs[face.v3 - coordsLen]; |
2014 | 2014 | ||
2015 | this.viewerFaces.Add(newViewerFace); | 2015 | this.viewerFaces.Add(newViewerFace); |
2016 | } | 2016 | } |
2017 | } | 2017 | } |
2018 | 2018 | ||
2019 | 2019 | ||
2020 | } // for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++) | 2020 | } // for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++) |
2021 | 2021 | ||
2022 | } | 2022 | } |
2023 | 2023 | ||
2024 | 2024 | ||
2025 | /// <summary> | 2025 | /// <summary> |
2026 | /// DEPRICATED - use Extrude(PathType.Linear) instead | 2026 | /// DEPRICATED - use Extrude(PathType.Linear) instead |
2027 | /// Extrudes a profile along a straight line path. Used for prim types box, cylinder, and prism. | 2027 | /// Extrudes a profile along a straight line path. Used for prim types box, cylinder, and prism. |
2028 | /// </summary> | 2028 | /// </summary> |
2029 | /// | 2029 | /// |
2030 | public void ExtrudeLinear() | 2030 | public void ExtrudeLinear() |
2031 | { | 2031 | { |
2032 | this.Extrude(PathType.Linear); | 2032 | this.Extrude(PathType.Linear); |
2033 | } | 2033 | } |
2034 | 2034 | ||
2035 | 2035 | ||
2036 | /// <summary> | 2036 | /// <summary> |
2037 | /// DEPRICATED - use Extrude(PathType.Circular) instead | 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. | 2038 | /// Extrude a profile into a circular path prim mesh. Used for prim types torus, tube, and ring. |
2039 | /// </summary> | 2039 | /// </summary> |
2040 | /// | 2040 | /// |
2041 | public void ExtrudeCircular() | 2041 | public void ExtrudeCircular() |
2042 | { | 2042 | { |
2043 | this.Extrude(PathType.Circular); | 2043 | this.Extrude(PathType.Circular); |
2044 | } | 2044 | } |
2045 | 2045 | ||
2046 | 2046 | ||
2047 | private Coord SurfaceNormal(Coord c1, Coord c2, Coord c3) | 2047 | private Coord SurfaceNormal(Coord c1, Coord c2, Coord c3) |
2048 | { | 2048 | { |
2049 | Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z); | 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); | 2050 | Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z); |
2051 | 2051 | ||
2052 | Coord normal = Coord.Cross(edge1, edge2); | 2052 | Coord normal = Coord.Cross(edge1, edge2); |
2053 | 2053 | ||
2054 | normal.Normalize(); | 2054 | normal.Normalize(); |
2055 | 2055 | ||
2056 | return normal; | 2056 | return normal; |
2057 | } | 2057 | } |
2058 | 2058 | ||
2059 | private Coord SurfaceNormal(Face face) | 2059 | private Coord SurfaceNormal(Face face) |
2060 | { | 2060 | { |
2061 | return SurfaceNormal(this.coords[face.v1], this.coords[face.v2], this.coords[face.v3]); | 2061 | return SurfaceNormal(this.coords[face.v1], this.coords[face.v2], this.coords[face.v3]); |
2062 | } | 2062 | } |
2063 | 2063 | ||
2064 | /// <summary> | 2064 | /// <summary> |
2065 | /// Calculate the surface normal for a face in the list of faces | 2065 | /// Calculate the surface normal for a face in the list of faces |
2066 | /// </summary> | 2066 | /// </summary> |
2067 | /// <param name="faceIndex"></param> | 2067 | /// <param name="faceIndex"></param> |
2068 | /// <returns></returns> | 2068 | /// <returns></returns> |
2069 | public Coord SurfaceNormal(int faceIndex) | 2069 | public Coord SurfaceNormal(int faceIndex) |
2070 | { | 2070 | { |
2071 | int numFaces = this.faces.Count; | 2071 | int numFaces = this.faces.Count; |
2072 | if (faceIndex < 0 || faceIndex >= numFaces) | 2072 | if (faceIndex < 0 || faceIndex >= numFaces) |
2073 | throw new Exception("faceIndex out of range"); | 2073 | throw new Exception("faceIndex out of range"); |
2074 | 2074 | ||
2075 | return SurfaceNormal(this.faces[faceIndex]); | 2075 | return SurfaceNormal(this.faces[faceIndex]); |
2076 | } | 2076 | } |
2077 | 2077 | ||
2078 | /// <summary> | 2078 | /// <summary> |
2079 | /// Duplicates a PrimMesh object. All object properties are copied by value, including lists. | 2079 | /// Duplicates a PrimMesh object. All object properties are copied by value, including lists. |
2080 | /// </summary> | 2080 | /// </summary> |
2081 | /// <returns></returns> | 2081 | /// <returns></returns> |
2082 | public PrimMesh Copy() | 2082 | public PrimMesh Copy() |
2083 | { | 2083 | { |
2084 | PrimMesh copy = new PrimMesh(this.sides, this.profileStart, this.profileEnd, this.hollow, this.hollowSides); | 2084 | PrimMesh copy = new PrimMesh(this.sides, this.profileStart, this.profileEnd, this.hollow, this.hollowSides); |
2085 | copy.twistBegin = this.twistBegin; | 2085 | copy.twistBegin = this.twistBegin; |
2086 | copy.twistEnd = this.twistEnd; | 2086 | copy.twistEnd = this.twistEnd; |
2087 | copy.topShearX = this.topShearX; | 2087 | copy.topShearX = this.topShearX; |
2088 | copy.topShearY = this.topShearY; | 2088 | copy.topShearY = this.topShearY; |
2089 | copy.pathCutBegin = this.pathCutBegin; | 2089 | copy.pathCutBegin = this.pathCutBegin; |
2090 | copy.pathCutEnd = this.pathCutEnd; | 2090 | copy.pathCutEnd = this.pathCutEnd; |
2091 | copy.dimpleBegin = this.dimpleBegin; | 2091 | copy.dimpleBegin = this.dimpleBegin; |
2092 | copy.dimpleEnd = this.dimpleEnd; | 2092 | copy.dimpleEnd = this.dimpleEnd; |
2093 | copy.skew = this.skew; | 2093 | copy.skew = this.skew; |
2094 | copy.holeSizeX = this.holeSizeX; | 2094 | copy.holeSizeX = this.holeSizeX; |
2095 | copy.holeSizeY = this.holeSizeY; | 2095 | copy.holeSizeY = this.holeSizeY; |
2096 | copy.taperX = this.taperX; | 2096 | copy.taperX = this.taperX; |
2097 | copy.taperY = this.taperY; | 2097 | copy.taperY = this.taperY; |
2098 | copy.radius = this.radius; | 2098 | copy.radius = this.radius; |
2099 | copy.revolutions = this.revolutions; | 2099 | copy.revolutions = this.revolutions; |
2100 | copy.stepsPerRevolution = this.stepsPerRevolution; | 2100 | copy.stepsPerRevolution = this.stepsPerRevolution; |
2101 | copy.calcVertexNormals = this.calcVertexNormals; | 2101 | copy.calcVertexNormals = this.calcVertexNormals; |
2102 | copy.normalsProcessed = this.normalsProcessed; | 2102 | copy.normalsProcessed = this.normalsProcessed; |
2103 | copy.viewerMode = this.viewerMode; | 2103 | copy.viewerMode = this.viewerMode; |
2104 | copy.numPrimFaces = this.numPrimFaces; | 2104 | copy.numPrimFaces = this.numPrimFaces; |
2105 | copy.errorMessage = this.errorMessage; | 2105 | copy.errorMessage = this.errorMessage; |
2106 | 2106 | ||
2107 | copy.coords = new List<Coord>(this.coords); | 2107 | copy.coords = new List<Coord>(this.coords); |
2108 | copy.faces = new List<Face>(this.faces); | 2108 | copy.faces = new List<Face>(this.faces); |
2109 | copy.viewerFaces = new List<ViewerFace>(this.viewerFaces); | 2109 | copy.viewerFaces = new List<ViewerFace>(this.viewerFaces); |
2110 | copy.normals = new List<Coord>(this.normals); | 2110 | copy.normals = new List<Coord>(this.normals); |
2111 | 2111 | ||
2112 | return copy; | 2112 | return copy; |
2113 | } | 2113 | } |
2114 | 2114 | ||
2115 | /// <summary> | 2115 | /// <summary> |
2116 | /// Calculate surface normals for all of the faces in the list of faces in this mesh | 2116 | /// Calculate surface normals for all of the faces in the list of faces in this mesh |
2117 | /// </summary> | 2117 | /// </summary> |
2118 | public void CalcNormals() | 2118 | public void CalcNormals() |
2119 | { | 2119 | { |
2120 | if (normalsProcessed) | 2120 | if (normalsProcessed) |
2121 | return; | 2121 | return; |
2122 | 2122 | ||
2123 | normalsProcessed = true; | 2123 | normalsProcessed = true; |
2124 | 2124 | ||
2125 | int numFaces = faces.Count; | 2125 | int numFaces = faces.Count; |
2126 | 2126 | ||
2127 | if (!this.calcVertexNormals) | 2127 | if (!this.calcVertexNormals) |
2128 | this.normals = new List<Coord>(); | 2128 | this.normals = new List<Coord>(); |
2129 | 2129 | ||
2130 | for (int i = 0; i < numFaces; i++) | 2130 | for (int i = 0; i < numFaces; i++) |
2131 | { | 2131 | { |
2132 | Face face = faces[i]; | 2132 | Face face = faces[i]; |
2133 | 2133 | ||
2134 | this.normals.Add(SurfaceNormal(i).Normalize()); | 2134 | this.normals.Add(SurfaceNormal(i).Normalize()); |
2135 | 2135 | ||
2136 | int normIndex = normals.Count - 1; | 2136 | int normIndex = normals.Count - 1; |
2137 | face.n1 = normIndex; | 2137 | face.n1 = normIndex; |
2138 | face.n2 = normIndex; | 2138 | face.n2 = normIndex; |
2139 | face.n3 = normIndex; | 2139 | face.n3 = normIndex; |
2140 | 2140 | ||
2141 | this.faces[i] = face; | 2141 | this.faces[i] = face; |
2142 | } | 2142 | } |
2143 | } | 2143 | } |
2144 | 2144 | ||
2145 | /// <summary> | 2145 | /// <summary> |
2146 | /// Adds a value to each XYZ vertex coordinate in the mesh | 2146 | /// Adds a value to each XYZ vertex coordinate in the mesh |
2147 | /// </summary> | 2147 | /// </summary> |
2148 | /// <param name="x"></param> | 2148 | /// <param name="x"></param> |
2149 | /// <param name="y"></param> | 2149 | /// <param name="y"></param> |
2150 | /// <param name="z"></param> | 2150 | /// <param name="z"></param> |
2151 | public void AddPos(float x, float y, float z) | 2151 | public void AddPos(float x, float y, float z) |
2152 | { | 2152 | { |
2153 | int i; | 2153 | int i; |
2154 | int numVerts = this.coords.Count; | 2154 | int numVerts = this.coords.Count; |
2155 | Coord vert; | 2155 | Coord vert; |
2156 | 2156 | ||
2157 | for (i = 0; i < numVerts; i++) | 2157 | for (i = 0; i < numVerts; i++) |
2158 | { | 2158 | { |
2159 | vert = this.coords[i]; | 2159 | vert = this.coords[i]; |
2160 | vert.X += x; | 2160 | vert.X += x; |
2161 | vert.Y += y; | 2161 | vert.Y += y; |
2162 | vert.Z += z; | 2162 | vert.Z += z; |
2163 | this.coords[i] = vert; | 2163 | this.coords[i] = vert; |
2164 | } | 2164 | } |
2165 | 2165 | ||
2166 | if (this.viewerFaces != null) | 2166 | if (this.viewerFaces != null) |
2167 | { | 2167 | { |
2168 | int numViewerFaces = this.viewerFaces.Count; | 2168 | int numViewerFaces = this.viewerFaces.Count; |
2169 | 2169 | ||
2170 | for (i = 0; i < numViewerFaces; i++) | 2170 | for (i = 0; i < numViewerFaces; i++) |
2171 | { | 2171 | { |
2172 | ViewerFace v = this.viewerFaces[i]; | 2172 | ViewerFace v = this.viewerFaces[i]; |
2173 | v.AddPos(x, y, z); | 2173 | v.AddPos(x, y, z); |
2174 | this.viewerFaces[i] = v; | 2174 | this.viewerFaces[i] = v; |
2175 | } | 2175 | } |
2176 | } | 2176 | } |
2177 | } | 2177 | } |
2178 | 2178 | ||
2179 | /// <summary> | 2179 | /// <summary> |
2180 | /// Rotates the mesh | 2180 | /// Rotates the mesh |
2181 | /// </summary> | 2181 | /// </summary> |
2182 | /// <param name="q"></param> | 2182 | /// <param name="q"></param> |
2183 | public void AddRot(Quat q) | 2183 | public void AddRot(Quat q) |
2184 | { | 2184 | { |
2185 | int i; | 2185 | int i; |
2186 | int numVerts = this.coords.Count; | 2186 | int numVerts = this.coords.Count; |
2187 | 2187 | ||
2188 | for (i = 0; i < numVerts; i++) | 2188 | for (i = 0; i < numVerts; i++) |
2189 | this.coords[i] *= q; | 2189 | this.coords[i] *= q; |
2190 | 2190 | ||
2191 | if (this.normals != null) | 2191 | if (this.normals != null) |
2192 | { | 2192 | { |
2193 | int numNormals = this.normals.Count; | 2193 | int numNormals = this.normals.Count; |
2194 | for (i = 0; i < numNormals; i++) | 2194 | for (i = 0; i < numNormals; i++) |
2195 | this.normals[i] *= q; | 2195 | this.normals[i] *= q; |
2196 | } | 2196 | } |
2197 | 2197 | ||
2198 | if (this.viewerFaces != null) | 2198 | if (this.viewerFaces != null) |
2199 | { | 2199 | { |
2200 | int numViewerFaces = this.viewerFaces.Count; | 2200 | int numViewerFaces = this.viewerFaces.Count; |
2201 | 2201 | ||
2202 | for (i = 0; i < numViewerFaces; i++) | 2202 | for (i = 0; i < numViewerFaces; i++) |
2203 | { | 2203 | { |
2204 | ViewerFace v = this.viewerFaces[i]; | 2204 | ViewerFace v = this.viewerFaces[i]; |
2205 | v.v1 *= q; | 2205 | v.v1 *= q; |
2206 | v.v2 *= q; | 2206 | v.v2 *= q; |
2207 | v.v3 *= q; | 2207 | v.v3 *= q; |
2208 | 2208 | ||
2209 | v.n1 *= q; | 2209 | v.n1 *= q; |
2210 | v.n2 *= q; | 2210 | v.n2 *= q; |
2211 | v.n3 *= q; | 2211 | v.n3 *= q; |
2212 | this.viewerFaces[i] = v; | 2212 | this.viewerFaces[i] = v; |
2213 | } | 2213 | } |
2214 | } | 2214 | } |
2215 | } | 2215 | } |
2216 | 2216 | ||
2217 | #if VERTEX_INDEXER | 2217 | #if VERTEX_INDEXER |
2218 | public VertexIndexer GetVertexIndexer() | 2218 | public VertexIndexer GetVertexIndexer() |
2219 | { | 2219 | { |
2220 | if (this.viewerMode && this.viewerFaces.Count > 0) | 2220 | if (this.viewerMode && this.viewerFaces.Count > 0) |
2221 | return new VertexIndexer(this); | 2221 | return new VertexIndexer(this); |
2222 | return null; | 2222 | return null; |
2223 | } | 2223 | } |
2224 | #endif | 2224 | #endif |
2225 | 2225 | ||
2226 | /// <summary> | 2226 | /// <summary> |
2227 | /// Scales the mesh | 2227 | /// Scales the mesh |
2228 | /// </summary> | 2228 | /// </summary> |
2229 | /// <param name="x"></param> | 2229 | /// <param name="x"></param> |
2230 | /// <param name="y"></param> | 2230 | /// <param name="y"></param> |
2231 | /// <param name="z"></param> | 2231 | /// <param name="z"></param> |
2232 | public void Scale(float x, float y, float z) | 2232 | public void Scale(float x, float y, float z) |
2233 | { | 2233 | { |
2234 | int i; | 2234 | int i; |
2235 | int numVerts = this.coords.Count; | 2235 | int numVerts = this.coords.Count; |
2236 | //Coord vert; | 2236 | //Coord vert; |
2237 | 2237 | ||
2238 | Coord m = new Coord(x, y, z); | 2238 | Coord m = new Coord(x, y, z); |
2239 | for (i = 0; i < numVerts; i++) | 2239 | for (i = 0; i < numVerts; i++) |
2240 | this.coords[i] *= m; | 2240 | this.coords[i] *= m; |
2241 | 2241 | ||
2242 | if (this.viewerFaces != null) | 2242 | if (this.viewerFaces != null) |
2243 | { | 2243 | { |
2244 | int numViewerFaces = this.viewerFaces.Count; | 2244 | int numViewerFaces = this.viewerFaces.Count; |
2245 | for (i = 0; i < numViewerFaces; i++) | 2245 | for (i = 0; i < numViewerFaces; i++) |
2246 | { | 2246 | { |
2247 | ViewerFace v = this.viewerFaces[i]; | 2247 | ViewerFace v = this.viewerFaces[i]; |
2248 | v.v1 *= m; | 2248 | v.v1 *= m; |
2249 | v.v2 *= m; | 2249 | v.v2 *= m; |
2250 | v.v3 *= m; | 2250 | v.v3 *= m; |
2251 | this.viewerFaces[i] = v; | 2251 | this.viewerFaces[i] = v; |
2252 | } | 2252 | } |
2253 | 2253 | ||
2254 | } | 2254 | } |
2255 | 2255 | ||
2256 | } | 2256 | } |
2257 | 2257 | ||
2258 | /// <summary> | 2258 | /// <summary> |
2259 | /// Dumps the mesh to a Blender compatible "Raw" format file | 2259 | /// Dumps the mesh to a Blender compatible "Raw" format file |
2260 | /// </summary> | 2260 | /// </summary> |
2261 | /// <param name="path"></param> | 2261 | /// <param name="path"></param> |
2262 | /// <param name="name"></param> | 2262 | /// <param name="name"></param> |
2263 | /// <param name="title"></param> | 2263 | /// <param name="title"></param> |
2264 | public void DumpRaw(String path, String name, String title) | 2264 | public void DumpRaw(String path, String name, String title) |
2265 | { | 2265 | { |
2266 | if (path == null) | 2266 | if (path == null) |
2267 | return; | 2267 | return; |
2268 | String fileName = name + "_" + title + ".raw"; | 2268 | String fileName = name + "_" + title + ".raw"; |
2269 | String completePath = System.IO.Path.Combine(path, fileName); | 2269 | String completePath = System.IO.Path.Combine(path, fileName); |
2270 | StreamWriter sw = new StreamWriter(completePath); | 2270 | StreamWriter sw = new StreamWriter(completePath); |
2271 | 2271 | ||
2272 | for (int i = 0; i < this.faces.Count; i++) | 2272 | for (int i = 0; i < this.faces.Count; i++) |
2273 | { | 2273 | { |
2274 | string s = this.coords[this.faces[i].v1].ToString(); | 2274 | string s = this.coords[this.faces[i].v1].ToString(); |
2275 | s += " " + this.coords[this.faces[i].v2].ToString(); | 2275 | s += " " + this.coords[this.faces[i].v2].ToString(); |
2276 | s += " " + this.coords[this.faces[i].v3].ToString(); | 2276 | s += " " + this.coords[this.faces[i].v3].ToString(); |
2277 | 2277 | ||
2278 | sw.WriteLine(s); | 2278 | sw.WriteLine(s); |
2279 | } | 2279 | } |
2280 | 2280 | ||
2281 | sw.Close(); | 2281 | sw.Close(); |
2282 | } | 2282 | } |
2283 | } | 2283 | } |
2284 | } | 2284 | } |