diff --git a/OpenSim/Region/Physics/Meshing/PrimMesher.cs b/OpenSim/Region/Physics/Meshing/PrimMesher.cs
index d7621d303a..168a3bb94b 100644
--- a/OpenSim/Region/Physics/Meshing/PrimMesher.cs
+++ b/OpenSim/Region/Physics/Meshing/PrimMesher.cs
@@ -27,32 +27,37 @@
using System;
using System.Collections.Generic;
-using OpenSim.Framework;
+using System.IO;
using OpenSim.Region.Physics.Manager;
namespace OpenSim.Region.Physics.Meshing
{
- public struct vertex
+ public struct Coord
{
public float X;
public float Y;
public float Z;
- public vertex(float x, float y, float z)
+ public Coord(float x, float y, float z)
{
this.X = x;
this.Y = y;
this.Z = z;
}
+
+ public override string ToString()
+ {
+ return this.X.ToString() + " " + this.Y.ToString() + " " + this.Z.ToString();
+ }
}
- public struct face
+ public struct Face
{
public int v1;
public int v2;
public int v3;
- public face(int v1, int v2, int v3)
+ public Face(int v1, int v2, int v3)
{
this.v1 = v1;
this.v2 = v2;
@@ -77,16 +82,17 @@ namespace OpenSim.Region.Physics.Meshing
internal class AngleList
{
private float iX, iY; // intersection point
- private void intersection( float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
+
+ private void intersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{ // ref: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
- float denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
- float uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+ double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+ double uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
if (denom != 0.0)
{
- float ua = uaNumerator / denom;
- iX = x1 + ua * (x2 - x1);
- iY = y1 + ua * (y2 - y1);
+ double ua = uaNumerator / denom;
+ iX = (float)(x1 + ua * (x2 - x1));
+ iY = (float)(y1 + ua * (y2 - y1));
}
}
@@ -107,14 +113,14 @@ namespace OpenSim.Region.Physics.Meshing
double stopAngleTest = stopAngle;
if (stopAngle < twoPi)
{
- stopAngleTest = stepSize * (int)(stopAngle / stepSize) + 1;
+ stopAngleTest = stepSize * ((int)(stopAngle / stepSize) + 1);
if (stopAngleTest < stopAngle)
stopAngleTest += stepSize;
if (stopAngleTest > twoPi)
stopAngleTest = twoPi;
}
-
- while (angle <= stopAngleTest)
+
+ while (angle <= stopAngleTest)
{
Angle newAngle;
newAngle.angle = (float) angle;
@@ -148,19 +154,28 @@ namespace OpenSim.Region.Physics.Meshing
}
}
- internal class makeProfile
+ ///
+ /// generates a profile for extrusion
+ ///
+ public class Profile
{
- private float twoPi = 2.0f * (float)Math.PI;
+ private const float twoPi = 2.0f * (float)Math.PI;
- internal List coords;
- internal List faces;
+ internal List coords;
+ internal List faces;
- internal makeProfile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides)
+ internal Profile()
{
- this.coords = new List();
- List hollowCoords = new List();
- this.faces = new List();
- vertex center = new vertex(0.0f, 0.0f, 0.0f);
+ this.coords = new List();
+ this.faces = new List();
+ }
+
+ public Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides)
+ {
+ this.coords = new List();
+ this.faces = new List();
+ Coord center = new Coord(0.0f, 0.0f, 0.0f);
+ List hollowCoords = new List();
AngleList angles = new AngleList();
AngleList hollowAngles = new AngleList();
@@ -184,17 +199,15 @@ namespace OpenSim.Region.Physics.Meshing
if (sides == hollowSides)
hollowAngles = angles;
else
- {
- hollowAngles = new AngleList();
hollowAngles.makeAngles(hollowSides, startAngle, stopAngle);
- }
}
else
this.coords.Add(center);
- Angle angle;
- vertex newVert = new vertex();
+ float z = 0.0f;
+ Angle angle;
+ Coord newVert = new Coord();
if (hollow > 0.001f && hollowSides != sides)
{
int numHollowAngles = hollowAngles.angles.Count;
@@ -203,40 +216,44 @@ namespace OpenSim.Region.Physics.Meshing
angle = hollowAngles.angles[i];
newVert.X = hollow * xScale * angle.X;
newVert.Y = hollow * yScale * angle.Y;
- newVert.Z = 0.0f;
+ newVert.Z = z;
hollowCoords.Add(newVert);
}
}
+ int index = 0;
int numAngles = angles.angles.Count;
- int index;
- for (index = 0; index < numAngles; index++)
+ for (int i = 0; i < numAngles; i++)
{
- angle = angles.angles[index];
+ angle = angles.angles[i];
newVert.X = angle.X * xScale;
newVert.Y = angle.Y * yScale;
- newVert.Z = 0.0f;
+ newVert.Z = z;
this.coords.Add(newVert);
if (hollow > 0.0f)
{
- newVert.X = angle.X *= hollow;
- newVert.Y = angle.Y *= hollow;
- newVert.Z = 0.0f;
- hollowCoords.Add(newVert);
+ if (hollowSides == sides)
+ {
+ newVert.X *= hollow;
+ newVert.Y *= hollow;
+ newVert.Z = z;
+ hollowCoords.Add(newVert);
+ }
}
else if (angle.angle > 0.0001f)
{
- face newFace = new face();
+ Face newFace = new Face();
newFace.v1 = 0;
newFace.v2 = index;
- newFace.v3 = index;
+ newFace.v3 = index + 1;
this.faces.Add(newFace);
}
+ index += 1;
}
- if (hollow > 0.0)
+ if (hollow > 0.0f)
{
hollowCoords.Reverse();
@@ -246,29 +263,26 @@ namespace OpenSim.Region.Physics.Meshing
if (numOuterVerts == numHollowVerts)
{
- face newFace = new face();
+ Face newFace = new Face();
for (int coordIndex = 0; coordIndex < numOuterVerts - 1; coordIndex++)
{
newFace.v1 = coordIndex;
newFace.v2 = coordIndex + 1;
newFace.v3 = numTotalVerts - coordIndex - 1;
-
this.faces.Add(newFace);
newFace.v1 = coordIndex + 1;
newFace.v2 = numTotalVerts - coordIndex - 2;
newFace.v3 = numTotalVerts - coordIndex - 1;
-
this.faces.Add(newFace);
}
}
-
else
{
if (numOuterVerts < numHollowVerts)
{
- face newFace = new face();
+ Face newFace = new Face();
int j = 0; // j is the index for outer vertices
int maxJ = numOuterVerts - 1;
for (int i = 0; i < numHollowVerts; i++) // i is the index for inner vertices
@@ -276,7 +290,7 @@ namespace OpenSim.Region.Physics.Meshing
if (j < maxJ)
if (angles.angles[j + 1].angle - hollowAngles.angles[i].angle <= hollowAngles.angles[i].angle - angles.angles[j].angle)
{
- newFace.v1 = numTotalVerts - i - 2;
+ newFace.v1 = numTotalVerts - i - 1;
newFace.v2 = j;
newFace.v3 = j + 1;
@@ -293,7 +307,7 @@ namespace OpenSim.Region.Physics.Meshing
}
else // numHollowVerts < numOuterVerts
{
- face newFace = new face();
+ Face newFace = new Face();
int j = 0; // j is the index for inner vertices
int maxJ = numHollowVerts - 1;
for (int i = 0; i < numOuterVerts; i++)
@@ -316,23 +330,32 @@ namespace OpenSim.Region.Physics.Meshing
this.faces.Add(newFace);
}
}
-
}
this.coords.AddRange(hollowCoords);
}
}
- internal void addPos(vertex v)
+ public Profile Clone()
{
- this.addPos(v.X, v.Y, v.Z);
+ Profile clone = new Profile();
+
+ clone.coords.AddRange(this.coords);
+ clone.faces.AddRange(this.faces);
+
+ return clone;
}
- internal void addPos(float x, float y, float z)
+ public void AddPos(Coord v)
+ {
+ this.AddPos(v.X, v.Y, v.Z);
+ }
+
+ public void AddPos(float x, float y, float z)
{
int i;
int numVerts = this.coords.Count;
- vertex vert;
+ Coord vert;
for (i = 0; i < numVerts; i++)
{
@@ -340,49 +363,48 @@ namespace OpenSim.Region.Physics.Meshing
vert.X += x;
vert.Y += y;
vert.Z += z;
+ this.coords[i] = vert;
}
}
- internal void addRot(Quaternion q)
+ public void AddRot(Quaternion q)
{
int i;
int numVerts = this.coords.Count;
- vertex vert;
+ Coord vert;
for (i = 0; i < numVerts; i++)
{
vert = this.coords[i];
- Vertex v = new Vertex(vert.X, vert.Y, vert.Z);
-
- v = v * q;
+ Vertex v = new Vertex(vert.X, vert.Y, vert.Z) * q;
vert.X = v.X;
vert.Y = v.Y;
vert.Z = v.Z;
+ this.coords[i] = vert;
}
}
- internal void scale(float x, float y, float z)
+ public void Scale(float x, float y)
{
int i;
int numVerts = this.coords.Count;
- vertex vert;
+ Coord vert;
for (i = 0; i < numVerts; i++)
{
vert = this.coords[i];
-
vert.X *= x;
vert.Y *= y;
- vert.Z *= z;
+ this.coords[i] = vert;
}
}
- internal void flipNormals()
+ public void FlipNormals()
{
int i;
int numFaces = this.faces.Count;
- face tmpFace;
+ Face tmpFace;
int tmp;
for (i = 0; i < numFaces; i++)
@@ -391,21 +413,534 @@ namespace OpenSim.Region.Physics.Meshing
tmp = tmpFace.v3;
tmpFace.v3 = tmpFace.v1;
tmpFace.v1 = tmp;
+ this.faces[i] = tmpFace;
}
}
+
+ public void AddValue2Faces(int num)
+ {
+ int numFaces = this.faces.Count;
+ Face tmpFace;
+ for (int i = 0; i < numFaces; i++)
+ {
+ tmpFace = this.faces[i];
+ tmpFace.v1 += num;
+ tmpFace.v2 += num;
+ tmpFace.v3 += num;
+ this.faces[i] = tmpFace;
+ }
+ }
+
+ public void DumpRaw(String path, String name, String title)
+ {
+ if (path == null)
+ return;
+ String fileName = name + "_" + title + ".raw";
+ String completePath = Path.Combine(path, fileName);
+ StreamWriter sw = new StreamWriter(completePath);
+
+ for (int i = 0; i < this.faces.Count; i++)
+ {
+ string s = this.coords[this.faces[i].v1].ToString();
+ s += " " + this.coords[this.faces[i].v2].ToString();
+ s += " " + this.coords[this.faces[i].v3].ToString();
+
+ sw.WriteLine(s);
+ }
+
+ sw.Close();
+ }
}
- public class PrimMesher
+ public class PrimMesh
{
- public List vertices;
- public List faces;
+ private const float twoPi = 2.0f * (float)Math.PI;
- PrimMesher()
+ public List coords;
+ public List faces;
+
+ public int sides = 4;
+ public int hollowSides = 4;
+ public float profileStart = 0.0f;
+ public float profileEnd = 1.0f;
+ public float hollow = 0.0f;
+ public int twistBegin = 0;
+ public int twistEnd = 0;
+ public float topShearX = 0.0f;
+ public float topShearY = 0.0f;
+ public float pathCutBegin = 0.0f;
+ public float pathCutEnd = 1.0f;
+ public float dimpleBegin = 0.0f;
+ public float dimpleEnd = 1.0f;
+ public float skew = 0.0f;
+ public float holeSizeX = 1.0f; // called pathScaleX in pbs
+ public float holeSizeY = 0.25f;
+ public float taperX = 0.0f;
+ public float taperY = 0.0f;
+ public float radius = 0.0f;
+ public float revolutions = 1.0f;
+ public int stepsPerRevolution = 24;
+
+ public string ParamsToDisplayString()
{
- vertices = new List();
- faces = new List();
+ string s = "";
+ s += "sides..................: " + this.sides.ToString();
+ s += "\nhollowSides..........: " + this.hollowSides.ToString();
+ s += "\nprofileStart.........: " + this.profileStart.ToString();
+ s += "\nprofileEnd...........: " + this.profileEnd.ToString();
+ s += "\nhollow...............: " + this.hollow.ToString();
+ s += "\ntwistBegin...........: " + this.twistBegin.ToString();
+ s += "\ntwistEnd.............: " + this.twistEnd.ToString();
+ s += "\ntopShearX............: " + this.topShearX.ToString();
+ s += "\ntopShearY............: " + this.topShearY.ToString();
+ s += "\npathCutBegin.........: " + this.pathCutBegin.ToString();
+ s += "\npathCutEnd...........: " + this.pathCutEnd.ToString();
+ s += "\ndimpleBegin..........: " + this.dimpleBegin.ToString();
+ s += "\ndimpleEnd............: " + this.dimpleEnd.ToString();
+ s += "\nskew.................: " + this.skew.ToString();
+ s += "\nholeSizeX............: " + this.holeSizeX.ToString();
+ s += "\nholeSizeY............: " + this.holeSizeY.ToString();
+ s += "\ntaperX...............: " + this.taperX.ToString();
+ s += "\ntaperY...............: " + this.taperY.ToString();
+ s += "\nradius...............: " + this.radius.ToString();
+ s += "\nrevolutions..........: " + this.revolutions.ToString();
+ s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString();
+
+ return s;
+ }
+ public PrimMesh(int sides, float profileStart, float profileEnd, float hollow, int hollowSides)
+ {
+ this.coords = new List();
+ this.faces = new List();
+
+ this.sides = sides;
+ this.profileStart = profileStart;
+ this.profileEnd = profileEnd;
+ this.hollow = hollow;
+ this.hollowSides = hollowSides;
+
+ if (sides < 3)
+ this.sides = 3;
+ if ( hollowSides < 3)
+ this.hollowSides = 3;
+ if (profileStart < 0.0f)
+ this.profileStart = 0.0f;
+ if (profileEnd > 1.0f)
+ this.profileEnd = 1.0f;
+ if (profileEnd < 0.02f)
+ this.profileEnd = 0.02f;
+ if (profileStart >= profileEnd)
+ this.profileStart = profileEnd - 0.02f;
+ if (hollow > 1.0f)
+ this.hollow = 1.0f;
+ if (hollow < 0.0f)
+ this.hollow = 0.0f;
+ }
+
+ public void ExtrudeLinear()
+ {
+ this.coords = new List();
+ this.faces = new List();
+
+ int step = 0;
+ int steps = 1;
+
+ float length = this.pathCutEnd - this.pathCutBegin;
+
+#if VIEWER
+ if (this.sides == 3)
+ {
+ // prisms don't taper well so add some vertical resolution
+ // other prims may benefit from this but just do prisms for now
+ if (Math.Abs(this.taperX) > 0.01 || Math.Abs(this.taperY) > 0.01)
+ steps = (int)(steps * 4.5 * length);
+ }
+#endif
+
+ float twistBegin = this.twistBegin / 360.0f * twoPi;
+ float twistEnd = this.twistEnd / 360.0f * twoPi;
+ float twistTotal = twistEnd - twistBegin;
+ float twistTotalAbs = Math.Abs(twistTotal);
+ if (twistTotalAbs > 0.01f)
+ steps += (int)(twistTotalAbs * 3.66); // dahlia's magic number
+
+ float start = -0.5f;
+ float stepSize = length / (float)steps;
+ float percentOfPathMultiplier = stepSize;
+ float xProfileScale = 1.0f;
+ float yProfileScale = 1.0f;
+ float xOffset = 0.0f;
+ float yOffset = 0.0f;
+ float zOffset = start;
+ float xOffsetStepIncrement = this.topShearX / steps;
+ float yOffsetStepIncrement = this.topShearY / steps;
+
+ float percentOfPath = this.pathCutBegin;
+ zOffset += percentOfPath;
+
+ float hollow = this.hollow;
+
+ // sanity checks
+ float initialProfileRot = 0.0f;
+ if (this.sides == 3)
+ {
+ if (this.hollowSides == 4)
+ {
+ if (hollow > 0.7f)
+ hollow = 0.7f;
+ hollow *= 0.707f;
+ }
+ else hollow *= 0.5f;
+ }
+ else if (this.sides == 4)
+ {
+ initialProfileRot = 1.25f * (float)Math.PI;
+ if (this.hollowSides != 4)
+ hollow *= 0.707f;
+ }
+
+ Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides);
+
+ if (initialProfileRot != 0.0f)
+ profile.AddRot(new Quaternion(new Vertex(0.0f, 0.0f, 1.0f), initialProfileRot));
+
+ bool done = false;
+ while (!done)
+ {
+ Profile newLayer = profile.Clone();
+
+ if (this.taperX == 0.0f)
+ xProfileScale = 1.0f;
+ else if (this.taperX > 0.0f)
+ xProfileScale = 1.0f - percentOfPath * this.taperX;
+ else xProfileScale = 1.0f + (1.0f - percentOfPath) * this.taperX;
+
+ if (this.taperY == 0.0f)
+ yProfileScale = 1.0f;
+ else if (this.taperY > 0.0f)
+ yProfileScale = 1.0f - percentOfPath * this.taperY;
+ else yProfileScale = 1.0f + (1.0f - percentOfPath) * this.taperY;
+
+ if (xProfileScale != 1.0f || yProfileScale != 1.0f)
+ newLayer.Scale(xProfileScale, yProfileScale);
+
+ float twist = twistBegin + twistTotal * percentOfPath;
+ if (twist != 0.0f)
+ newLayer.AddRot(new Quaternion(new Vertex(0.0f, 0.0f, 1.0f), twist));
+
+ newLayer.AddPos(xOffset, yOffset, zOffset);
+
+ if (step == 0)
+ newLayer.FlipNormals();
+
+ // append this layer
+
+ int coordsLen = this.coords.Count;
+ newLayer.AddValue2Faces(coordsLen);
+
+ this.coords.AddRange(newLayer.coords);
+ this.faces.AddRange(newLayer.faces);
+
+ // fill faces between layers
+
+ int numVerts = newLayer.coords.Count;
+ Face newFace = new Face();
+ if (step > 0)
+ {
+ for (int i = coordsLen; i < this.coords.Count - 1; i++)
+ {
+ newFace.v1 = i;
+ newFace.v2 = i - numVerts;
+ newFace.v3 = i - numVerts + 1;
+ this.faces.Add(newFace);
+
+ newFace.v2 = i - numVerts + 1;
+ newFace.v3 = i + 1;
+ this.faces.Add(newFace);
+ }
+
+ newFace.v1 = coordsLen - 1;
+ newFace.v2 = coordsLen - numVerts;
+ newFace.v3 = coordsLen;
+ this.faces.Add(newFace);
+
+ newFace.v1 = coordsLen + numVerts - 1;
+ newFace.v2 = coordsLen - 1;
+ newFace.v3 = coordsLen;
+ this.faces.Add(newFace);
+ }
+
+ // calc the step for the next iteration of the loop
+
+ if (step < steps)
+ {
+ step += 1;
+ percentOfPath += percentOfPathMultiplier;
+ xOffset += xOffsetStepIncrement;
+ yOffset += yOffsetStepIncrement;
+ zOffset += stepSize;
+ if (percentOfPath > this.pathCutEnd)
+ done = true;
+ }
+ else done = true;
+ }
+ }
+
+
+ public void ExtrudeCircular()
+ {
+ this.coords = new List();
+ this.faces = new List();
+
+ int step = 0;
+ int steps = 24;
+
+ float twistBegin = this.twistBegin / 360.0f * twoPi;
+ float twistEnd = this.twistEnd / 360.0f * twoPi;
+ float twistTotal = twistEnd - twistBegin;
+
+ // if the profile has a lot of twist, add more layers otherwise the layers may overlap
+ // and the resulting mesh may be quite inaccurate. This method is arbitrary and doesn't
+ // accurately match the viewer
+ float twistTotalAbs = Math.Abs(twistTotal);
+ if (twistTotalAbs > 0.01f)
+ {
+ if (twistTotalAbs > Math.PI * 1.5f)
+ steps *= 2;
+ if (twistTotalAbs > Math.PI * 3.0f)
+ steps *= 2;
+ }
+
+ float yPathScale = this.holeSizeY * 0.5f;
+ float pathLength = this.pathCutEnd - this.pathCutBegin;
+ float totalSkew = this.skew * 2.0f * pathLength;
+ float skewStart = this.pathCutBegin * 2.0f * this.skew - this.skew;
+
+ // It's not quite clear what pushY (Y top shear) does, but subtracting it from the start and end
+ // angles appears to approximate it's effects on path cut. Likewise, adding it to the angle used
+ // to calculate the sine for generating the path radius appears to approximate it's effects there
+ // too, but there are some subtle differences in the radius which are noticeable as the prim size
+ // increases and it may affect megaprims quite a bit. The effect of the Y top shear parameter on
+ // the meshes generated with this technique appear nearly identical in shape to the same prims when
+ // displayed by the viewer.
+
+ float startAngle = (twoPi * this.pathCutBegin * this.revolutions) - this.topShearY * 0.9f;
+ float endAngle = (twoPi * this.pathCutEnd * this.revolutions) - this.topShearY * 0.9f;
+ float stepSize = twoPi / this.stepsPerRevolution;
+
+ step = (int)(startAngle / stepSize);
+ int firstStep = step;
+ float angle = startAngle;
+ float hollow = this.hollow;
+
+ // sanity checks
+ float initialProfileRot = 0.0f;
+ if (this.sides == 3)
+ {
+ initialProfileRot = (float)Math.PI;
+ if (this.hollowSides == 4)
+ {
+ if (hollow > 0.7f)
+ hollow = 0.7f;
+ hollow *= 0.707f;
+ }
+ else hollow *= 0.5f;
+ }
+ else if (this.sides == 4)
+ {
+ initialProfileRot = 0.25f * (float)Math.PI;
+ if (this.hollowSides != 4)
+ hollow *= 0.707f;
+ }
+ else if (this.sides > 4)
+ {
+ initialProfileRot = (float)Math.PI;
+ if (this.hollowSides == 4)
+ {
+ if (hollow > 0.7f)
+ hollow = 0.7f;
+ hollow /= 0.7f;
+ }
+ }
+
+ Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides);
+
+ if (initialProfileRot != 0.0f)
+ profile.AddRot(new Quaternion(new Vertex(0.0f, 0.0f, 1.0f), initialProfileRot));
+
+ bool done = false;
+ while (!done) // loop through the length of the path and add the layers
+ {
+ Profile newLayer = profile.Clone();
+
+ float xProfileScale = (1.0f - Math.Abs(this.skew)) * this.holeSizeX;
+ float yProfileScale = this.holeSizeY;
+
+ float percentOfPath = angle / (twoPi * this.revolutions);
+ float percentOfAngles = (angle - startAngle) / (endAngle - startAngle);
+
+ if (this.taperX > 0.01f)
+ xProfileScale *= 1.0f - percentOfPath * this.taperX;
+ else if (this.taperX < -0.01f)
+ xProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperX;
+
+ if (this.taperY > 0.01f)
+ yProfileScale *= 1.0f - percentOfPath * this.taperY;
+ else if (this.taperY < -0.01f)
+ yProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperY;
+
+ if (xProfileScale != 1.0f || yProfileScale != 1.0f)
+ newLayer.Scale(xProfileScale, yProfileScale);
+
+ float radiusScale = 1.0f;
+ if (this.radius > 0.001f)
+ radiusScale = 1.0f - this.radius * percentOfPath;
+ else if (this.radius < 0.001f)
+ radiusScale = 1.0f + this.radius * (1.0f - percentOfPath);
+
+ float twist = twistBegin + twistTotal * percentOfPath;
+
+ float xOffset = 0.5f * (skewStart + totalSkew * percentOfAngles);
+
+ xOffset += (float)Math.Sin(angle) * this.topShearX * 0.45f;
+ float yOffset = (float)Math.Cos(angle) * (0.5f - yPathScale) * radiusScale;
+
+ float zOffset = (float)Math.Sin(angle + this.topShearY * 0.9f) * (0.5f - yPathScale) * radiusScale;
+
+ // next apply twist rotation to the profile layer
+ if (twistTotal != 0.0f || twistBegin != 0.0f)
+ newLayer.AddRot(new Quaternion(new Vertex(0.0f, 0.0f, 1.0f), twist));
+
+ // now orient the rotation of the profile layer relative to it's position on the path
+ // adding taperY to the angle used to generate the quat appears to approximate the viewer
+ newLayer.AddRot(new Quaternion(new Vertex(1.0f, 0.0f, 0.0f), angle + this.topShearY * 0.9f));
+ newLayer.AddPos(xOffset, yOffset, zOffset);
+
+ if (angle == startAngle)
+ newLayer.FlipNormals();
+
+ // append the layer and fill in the sides
+
+ int coordsLen = this.coords.Count;
+ newLayer.AddValue2Faces(coordsLen);
+
+ this.coords.AddRange(newLayer.coords);
+ this.faces.AddRange(newLayer.faces);
+
+ // fill faces between layers
+
+ int numVerts = newLayer.coords.Count;
+ Face newFace = new Face();
+ if (step > firstStep)
+ {
+ for (int i = coordsLen; i < this.coords.Count - 1; i++)
+ {
+ newFace.v1 = i;
+ newFace.v2 = i - numVerts;
+ newFace.v3 = i - numVerts + 1;
+ this.faces.Add(newFace);
+
+ newFace.v2 = i - numVerts + 1;
+ newFace.v3 = i + 1;
+ this.faces.Add(newFace);
+ }
+
+ newFace.v1 = coordsLen - 1;
+ newFace.v2 = coordsLen - numVerts;
+ newFace.v3 = coordsLen;
+ this.faces.Add(newFace);
+
+ newFace.v1 = coordsLen + numVerts - 1;
+ newFace.v2 = coordsLen - 1;
+ newFace.v3 = coordsLen;
+ this.faces.Add(newFace);
+ }
+
+ // calculate terms for next iteration
+ // calculate the angle for the next iteration of the loop
+
+ if (angle >= endAngle)
+ done = true;
+ else
+ {
+ step += 1;
+ angle = stepSize * step;
+ if (angle > endAngle)
+ angle = endAngle;
+ }
+ }
+ }
+
+ public void AddPos(float x, float y, float z)
+ {
+ int i;
+ int numVerts = this.coords.Count;
+ Coord vert;
+
+ for (i = 0; i < numVerts; i++)
+ {
+ vert = this.coords[i];
+ vert.X += x;
+ vert.Y += y;
+ vert.Z += z;
+ this.coords[i] = vert;
+ }
+ }
+
+ public void AddRot(Quaternion q)
+ {
+ int i;
+ int numVerts = this.coords.Count;
+ Coord vert;
+
+ for (i = 0; i < numVerts; i++)
+ {
+ vert = this.coords[i];
+ Vertex v = new Vertex(vert.X, vert.Y, vert.Z) * q;
+
+ vert.X = v.X;
+ vert.Y = v.Y;
+ vert.Z = v.Z;
+ this.coords[i] = vert;
+ }
+ }
+
+ public void Scale(float x, float y, float z)
+ {
+ int i;
+ int numVerts = this.coords.Count;
+ Coord vert;
+
+ for (i = 0; i < numVerts; i++)
+ {
+ vert = this.coords[i];
+ vert.X *= x;
+ vert.Y *= y;
+ vert.Z *= z;
+ this.coords[i] = vert;
+ }
+ }
+
+ public void DumpRaw(String path, String name, String title)
+ {
+ if (path == null)
+ return;
+ String fileName = name + "_" + title + ".raw";
+ String completePath = Path.Combine(path, fileName);
+ StreamWriter sw = new StreamWriter(completePath);
+
+ for (int i = 0; i < this.faces.Count; i++)
+ {
+ string s = this.coords[this.faces[i].v1].ToString();
+ s += " " + this.coords[this.faces[i].v2].ToString();
+ s += " " + this.coords[this.faces[i].v3].ToString();
+
+ sw.WriteLine(s);
+ }
+
+ sw.Close();
}
}
}