public void GeographicGridEllipsoidTessellatorTest()
{
Mesh mesh = GeographicGridEllipsoidTessellator.Compute(Ellipsoid.UnitSphere, 8, 4, GeographicGridEllipsoidVertexAttributes.All);
VertexAttributeDoubleVector3 positions = (VertexAttributeDoubleVector3)mesh.Attributes["position"];
VertexAttributeHalfFloatVector3 normals = (VertexAttributeHalfFloatVector3)mesh.Attributes["normal"];
VertexAttributeHalfFloatVector2 textureCoordinates = (VertexAttributeHalfFloatVector2)mesh.Attributes["textureCoordinate"];
Assert.AreEqual(positions.Values.Count, normals.Values.Count);
Assert.AreEqual(positions.Values.Count, textureCoordinates.Values.Count);
}
public static Mesh Compute(Ellipsoid ellipsoid, int numberOfSubdivisions, SubdivisionEllipsoidVertexAttributes vertexAttributes)
{
if (numberOfSubdivisions < 0)
{
throw new ArgumentOutOfRangeException("numberOfSubdivisions");
}
if ((vertexAttributes & SubdivisionEllipsoidVertexAttributes.Position) != SubdivisionEllipsoidVertexAttributes.Position)
{
throw new ArgumentException("Positions must be provided.", "vertexAttributes");
}
Mesh mesh = new Mesh();
mesh.PrimitiveType = PrimitiveType.Triangles;
mesh.FrontFaceWindingOrder = WindingOrder.Counterclockwise;
int numberOfVertices = SubdivisionUtility.NumberOfVertices(numberOfSubdivisions);
VertexAttributeDoubleVector3 positionsAttribute = new VertexAttributeDoubleVector3("position", numberOfVertices);
mesh.Attributes.Add(positionsAttribute);
IndicesUnsignedInt indices = new IndicesUnsignedInt(3 * SubdivisionUtility.NumberOfTriangles(numberOfSubdivisions));
mesh.Indices = indices;
SubdivisionMesh subdivisionMesh = new SubdivisionMesh();
subdivisionMesh.Ellipsoid = ellipsoid;
subdivisionMesh.Positions = positionsAttribute.Values;
subdivisionMesh.Indices = indices;
if ((vertexAttributes & SubdivisionEllipsoidVertexAttributes.Normal) == SubdivisionEllipsoidVertexAttributes.Normal)
{
VertexAttributeHalfFloatVector3 normalsAttribute = new VertexAttributeHalfFloatVector3("normal", numberOfVertices);
mesh.Attributes.Add(normalsAttribute);
subdivisionMesh.Normals = normalsAttribute.Values;
}
if ((vertexAttributes & SubdivisionEllipsoidVertexAttributes.TextureCoordinate) == SubdivisionEllipsoidVertexAttributes.TextureCoordinate)
{
VertexAttributeHalfFloatVector2 textureCoordinateAttribute = new VertexAttributeHalfFloatVector2("textureCoordinate", numberOfVertices);
mesh.Attributes.Add(textureCoordinateAttribute);
subdivisionMesh.TextureCoordinate = textureCoordinateAttribute.Values;
}
//
// Initial tetrahedron
//
double negativeRootTwoOverThree = -Math.Sqrt(2.0) / 3.0;
const double negativeOneThird = -1.0 / 3.0;
double rootSixOverThree = Math.Sqrt(6.0) / 3.0;
Vector3D n0 = new Vector3D(0, 0, 1);
Vector3D n1 = new Vector3D(0, (2.0 * Math.Sqrt(2.0)) / 3.0, negativeOneThird);
Vector3D n2 = new Vector3D(-rootSixOverThree, negativeRootTwoOverThree, negativeOneThird);
Vector3D n3 = new Vector3D(rootSixOverThree, negativeRootTwoOverThree, negativeOneThird);
Vector3D p0 = n0.MultiplyComponents(ellipsoid.Radii);
Vector3D p1 = n1.MultiplyComponents(ellipsoid.Radii);
Vector3D p2 = n2.MultiplyComponents(ellipsoid.Radii);
Vector3D p3 = n3.MultiplyComponents(ellipsoid.Radii);
subdivisionMesh.Positions.Add(p0);
subdivisionMesh.Positions.Add(p1);
subdivisionMesh.Positions.Add(p2);
subdivisionMesh.Positions.Add(p3);
if ((subdivisionMesh.Normals != null) || (subdivisionMesh.TextureCoordinate != null))
{
Vector3D d0 = ellipsoid.GeodeticSurfaceNormal(p0);
Vector3D d1 = ellipsoid.GeodeticSurfaceNormal(p1);
Vector3D d2 = ellipsoid.GeodeticSurfaceNormal(p2);
Vector3D d3 = ellipsoid.GeodeticSurfaceNormal(p3);
if (subdivisionMesh.Normals != null)
{
subdivisionMesh.Normals.Add(d0.ToVector3H());
subdivisionMesh.Normals.Add(d1.ToVector3H());
subdivisionMesh.Normals.Add(d2.ToVector3H());
subdivisionMesh.Normals.Add(d3.ToVector3H());
}
if (subdivisionMesh.TextureCoordinate != null)
{
subdivisionMesh.TextureCoordinate.Add(SubdivisionUtility.ComputeTextureCoordinate(d0));
subdivisionMesh.TextureCoordinate.Add(SubdivisionUtility.ComputeTextureCoordinate(d1));
subdivisionMesh.TextureCoordinate.Add(SubdivisionUtility.ComputeTextureCoordinate(d2));
subdivisionMesh.TextureCoordinate.Add(SubdivisionUtility.ComputeTextureCoordinate(d3));
}
}
Subdivide(subdivisionMesh, new TriangleIndicesUnsignedInt(0, 1, 2), numberOfSubdivisions);
Subdivide(subdivisionMesh, new TriangleIndicesUnsignedInt(0, 2, 3), numberOfSubdivisions);
Subdivide(subdivisionMesh, new TriangleIndicesUnsignedInt(0, 3, 1), numberOfSubdivisions);
Subdivide(subdivisionMesh, new TriangleIndicesUnsignedInt(1, 3, 2), numberOfSubdivisions);
return(mesh);
}
public static Mesh Compute(Ellipsoid ellipsoid, int numberOfPartitions, CubeMapEllipsoidVertexAttributes vertexAttributes)
{
if (numberOfPartitions < 0)
{
throw new ArgumentOutOfRangeException("numberOfPartitions");
}
if ((vertexAttributes & CubeMapEllipsoidVertexAttributes.Position) != CubeMapEllipsoidVertexAttributes.Position)
{
throw new ArgumentException("Positions must be provided.", "vertexAttributes");
}
Mesh mesh = new Mesh();
mesh.PrimitiveType = PrimitiveType.Triangles;
mesh.FrontFaceWindingOrder = WindingOrder.Counterclockwise;
int numberOfVertices = NumberOfVertices(numberOfPartitions);
VertexAttributeDoubleVector3 positionsAttribute = new VertexAttributeDoubleVector3("position", numberOfVertices);
mesh.Attributes.Add(positionsAttribute);
IndicesUnsignedInt indices = new IndicesUnsignedInt(3 * NumberOfTriangles(numberOfPartitions));
mesh.Indices = indices;
CubeMapMesh CubeMapMesh = new CubeMapMesh();
CubeMapMesh.Ellipsoid = ellipsoid;
CubeMapMesh.NumberOfPartitions = numberOfPartitions;
CubeMapMesh.Positions = positionsAttribute.Values;
CubeMapMesh.Indices = indices;
if ((vertexAttributes & CubeMapEllipsoidVertexAttributes.Normal) == CubeMapEllipsoidVertexAttributes.Normal)
{
VertexAttributeHalfFloatVector3 normalsAttribute = new VertexAttributeHalfFloatVector3("normal", numberOfVertices);
mesh.Attributes.Add(normalsAttribute);
CubeMapMesh.Normals = normalsAttribute.Values;
}
if ((vertexAttributes & CubeMapEllipsoidVertexAttributes.TextureCoordinate) == CubeMapEllipsoidVertexAttributes.TextureCoordinate)
{
VertexAttributeHalfFloatVector2 textureCoordinateAttribute = new VertexAttributeHalfFloatVector2("textureCoordinate", numberOfVertices);
mesh.Attributes.Add(textureCoordinateAttribute);
CubeMapMesh.TextureCoordinate = textureCoordinateAttribute.Values;
}
//
// Initial cube. In the plane, z = -1:
//
// +y
// |
// Q2 * p3 Q1
// / | \
// p0 *--+--* p2 +x
// \ | /
// Q3 * p1 Q4
// |
//
// Similarly, p4 to p7 are in the plane z = 1.
//
CubeMapMesh.Positions.Add(new Vector3D(-1, 0, -1));
CubeMapMesh.Positions.Add(new Vector3D(0, -1, -1));
CubeMapMesh.Positions.Add(new Vector3D(1, 0, -1));
CubeMapMesh.Positions.Add(new Vector3D(0, 1, -1));
CubeMapMesh.Positions.Add(new Vector3D(-1, 0, 1));
CubeMapMesh.Positions.Add(new Vector3D(0, -1, 1));
CubeMapMesh.Positions.Add(new Vector3D(1, 0, 1));
CubeMapMesh.Positions.Add(new Vector3D(0, 1, 1));
//
// Edges
//
// 0 -> 1, 1 -> 2, 2 -> 3, 3 -> 0. Plane z = -1
// 4 -> 5, 5 -> 6, 6 -> 7, 7 -> 4. Plane z = 1
// 0 -> 4, 1 -> 5, 2 -> 6, 3 -> 7. From plane z = -1 to plane z - 1
//
int[] edge0to1 = AddEdgePositions(0, 1, CubeMapMesh);
int[] edge1to2 = AddEdgePositions(1, 2, CubeMapMesh);
int[] edge2to3 = AddEdgePositions(2, 3, CubeMapMesh);
int[] edge3to0 = AddEdgePositions(3, 0, CubeMapMesh);
int[] edge4to5 = AddEdgePositions(4, 5, CubeMapMesh);
int[] edge5to6 = AddEdgePositions(5, 6, CubeMapMesh);
int[] edge6to7 = AddEdgePositions(6, 7, CubeMapMesh);
int[] edge7to4 = AddEdgePositions(7, 4, CubeMapMesh);
int[] edge0to4 = AddEdgePositions(0, 4, CubeMapMesh);
int[] edge1to5 = AddEdgePositions(1, 5, CubeMapMesh);
int[] edge2to6 = AddEdgePositions(2, 6, CubeMapMesh);
int[] edge3to7 = AddEdgePositions(3, 7, CubeMapMesh);
AddFaceTriangles(edge0to4, edge0to1, edge1to5, edge4to5, CubeMapMesh); // Q3 Face
AddFaceTriangles(edge1to5, edge1to2, edge2to6, edge5to6, CubeMapMesh); // Q4 Face
AddFaceTriangles(edge2to6, edge2to3, edge3to7, edge6to7, CubeMapMesh); // Q1 Face
AddFaceTriangles(edge3to7, edge3to0, edge0to4, edge7to4, CubeMapMesh); // Q2 Face
AddFaceTriangles(ReversedArray(edge7to4), edge4to5, edge5to6, ReversedArray(edge6to7), CubeMapMesh); // Plane z = 1
AddFaceTriangles(edge1to2, ReversedArray(edge0to1), ReversedArray(edge3to0), edge2to3, CubeMapMesh); // Plane z = -1
CubeToEllipsoid(CubeMapMesh);
return(mesh);
}
public static Mesh Compute(Ellipsoid ellipsoid, int numberOfSlicePartitions, int numberOfStackPartitions, GeographicGridEllipsoidVertexAttributes vertexAttributes)
{
if (numberOfSlicePartitions < 3)
{
throw new ArgumentOutOfRangeException("numberOfSlicePartitions");
}
if (numberOfStackPartitions < 2)
{
throw new ArgumentOutOfRangeException("numberOfStackPartitions");
}
if ((vertexAttributes & GeographicGridEllipsoidVertexAttributes.Position) != GeographicGridEllipsoidVertexAttributes.Position)
{
throw new ArgumentException("Positions must be provided.", "vertexAttributes");
}
Mesh mesh = new Mesh();
mesh.PrimitiveType = PrimitiveType.Triangles;
mesh.FrontFaceWindingOrder = WindingOrder.Counterclockwise;
int numberOfVertices = NumberOfVertices(numberOfSlicePartitions, numberOfStackPartitions);
VertexAttributeDoubleVector3 positionsAttribute = new VertexAttributeDoubleVector3("position", numberOfVertices);
mesh.Attributes.Add(positionsAttribute);
IndicesUnsignedInt indices = new IndicesUnsignedInt(3 * NumberOfTriangles(numberOfSlicePartitions, numberOfStackPartitions));
mesh.Indices = indices;
IList <Vector3H> normals = null;
if ((vertexAttributes & GeographicGridEllipsoidVertexAttributes.Normal) == GeographicGridEllipsoidVertexAttributes.Normal)
{
VertexAttributeHalfFloatVector3 normalsAttribute = new VertexAttributeHalfFloatVector3("normal", numberOfVertices);
mesh.Attributes.Add(normalsAttribute);
normals = normalsAttribute.Values;
}
IList <Vector2H> textureCoordinates = null;
if ((vertexAttributes & GeographicGridEllipsoidVertexAttributes.TextureCoordinate) == GeographicGridEllipsoidVertexAttributes.TextureCoordinate)
{
VertexAttributeHalfFloatVector2 textureCoordinateAttribute = new VertexAttributeHalfFloatVector2("textureCoordinate", numberOfVertices);
mesh.Attributes.Add(textureCoordinateAttribute);
textureCoordinates = textureCoordinateAttribute.Values;
}
//
// Create lookup table
//
double[] cosTheta = new double[numberOfSlicePartitions];
double[] sinTheta = new double[numberOfSlicePartitions];
for (int j = 0; j < numberOfSlicePartitions; ++j)
{
double theta = Trig.TwoPi * (((double)j) / numberOfSlicePartitions);
cosTheta[j] = Math.Cos(theta);
sinTheta[j] = Math.Sin(theta);
}
//
// Create positions
//
IList <Vector3D> positions = positionsAttribute.Values;
positions.Add(new Vector3D(0, 0, ellipsoid.Radii.Z));
for (int i = 1; i < numberOfStackPartitions; ++i)
{
double phi = Math.PI * (((double)i) / numberOfStackPartitions);
double sinPhi = Math.Sin(phi);
double xSinPhi = ellipsoid.Radii.X * sinPhi;
double ySinPhi = ellipsoid.Radii.Y * sinPhi;
double zCosPhi = ellipsoid.Radii.Z * Math.Cos(phi);
for (int j = 0; j < numberOfSlicePartitions; ++j)
{
positions.Add(new Vector3D(cosTheta[j] * xSinPhi, sinTheta[j] * ySinPhi, zCosPhi));
}
}
positions.Add(new Vector3D(0, 0, -ellipsoid.Radii.Z));
if ((normals != null) || (textureCoordinates != null))
{
for (int i = 0; i < positions.Count; ++i)
{
Vector3D deticSurfaceNormal = ellipsoid.GeodeticSurfaceNormal(positions[i]);
if (normals != null)
{
normals.Add(deticSurfaceNormal.ToVector3H());
}
if (textureCoordinates != null)
{
textureCoordinates.Add(SubdivisionUtility.ComputeTextureCoordinate(deticSurfaceNormal));
}
}
}
//
// Triangle fan top row
//
for (int j = 1; j < numberOfSlicePartitions; ++j)
{
indices.AddTriangle(new TriangleIndicesUnsignedInt(0, j, j + 1));
}
indices.AddTriangle(new TriangleIndicesUnsignedInt(0, numberOfSlicePartitions, 1));
//
// Middle rows are triangle strips
//
for (int i = 0; i < numberOfStackPartitions - 2; ++i)
{
int topRowOffset = (i * numberOfSlicePartitions) + 1;
int bottomRowOffset = ((i + 1) * numberOfSlicePartitions) + 1;
for (int j = 0; j < numberOfSlicePartitions - 1; ++j)
{
indices.AddTriangle(new TriangleIndicesUnsignedInt(bottomRowOffset + j, bottomRowOffset + j + 1, topRowOffset + j + 1));
indices.AddTriangle(new TriangleIndicesUnsignedInt(bottomRowOffset + j, topRowOffset + j + 1, topRowOffset + j));
}
indices.AddTriangle(new TriangleIndicesUnsignedInt(bottomRowOffset + numberOfSlicePartitions - 1, bottomRowOffset, topRowOffset));
indices.AddTriangle(new TriangleIndicesUnsignedInt(bottomRowOffset + numberOfSlicePartitions - 1, topRowOffset, topRowOffset + numberOfSlicePartitions - 1));
}
//
// Triangle fan bottom row
//
int lastPosition = positions.Count - 1;
for (int j = lastPosition - 1; j > lastPosition - numberOfSlicePartitions; --j)
{
indices.AddTriangle(new TriangleIndicesUnsignedInt(lastPosition, j, j - 1));
}
indices.AddTriangle(new TriangleIndicesUnsignedInt(lastPosition, lastPosition - numberOfSlicePartitions, lastPosition - 1));
return(mesh);
}
public void MeshVertexAttributes()
{
Mesh mesh = new Mesh();
VertexAttributeHalfFloat halfFloatAttribute = new VertexAttributeHalfFloat("halfFloatAttribute");
mesh.Attributes.Add(halfFloatAttribute);
Assert.AreEqual("halfFloatAttribute", mesh.Attributes["halfFloatAttribute"].Name);
Assert.AreEqual(VertexAttributeType.HalfFloat, mesh.Attributes["halfFloatAttribute"].Datatype);
VertexAttributeHalfFloatVector2 halfFloatAttribute2 = new VertexAttributeHalfFloatVector2("halfFloatAttribute2");
mesh.Attributes.Add(halfFloatAttribute2);
Assert.AreEqual("halfFloatAttribute2", mesh.Attributes["halfFloatAttribute2"].Name);
Assert.AreEqual(VertexAttributeType.HalfFloatVector2, mesh.Attributes["halfFloatAttribute2"].Datatype);
VertexAttributeHalfFloatVector3 halfFloatAttribute3 = new VertexAttributeHalfFloatVector3("halfFloatAttribute3");
mesh.Attributes.Add(halfFloatAttribute3);
Assert.AreEqual("halfFloatAttribute3", mesh.Attributes["halfFloatAttribute3"].Name);
Assert.AreEqual(VertexAttributeType.HalfFloatVector3, mesh.Attributes["halfFloatAttribute3"].Datatype);
VertexAttributeHalfFloatVector4 halfFloatAttribute4 = new VertexAttributeHalfFloatVector4("halfFloatAttribute4");
mesh.Attributes.Add(halfFloatAttribute4);
Assert.AreEqual("halfFloatAttribute4", mesh.Attributes["halfFloatAttribute4"].Name);
Assert.AreEqual(VertexAttributeType.HalfFloatVector4, mesh.Attributes["halfFloatAttribute4"].Datatype);
///////////////////////////////////////////////////////////////////
VertexAttributeFloat floatAttribute = new VertexAttributeFloat("floatAttribute");
mesh.Attributes.Add(floatAttribute);
Assert.AreEqual("floatAttribute", mesh.Attributes["floatAttribute"].Name);
Assert.AreEqual(VertexAttributeType.Float, mesh.Attributes["floatAttribute"].Datatype);
VertexAttributeFloatVector2 floatAttribute2 = new VertexAttributeFloatVector2("floatAttribute2");
mesh.Attributes.Add(floatAttribute2);
Assert.AreEqual("floatAttribute2", mesh.Attributes["floatAttribute2"].Name);
Assert.AreEqual(VertexAttributeType.FloatVector2, mesh.Attributes["floatAttribute2"].Datatype);
VertexAttributeFloatVector3 floatAttribute3 = new VertexAttributeFloatVector3("floatAttribute3");
mesh.Attributes.Add(floatAttribute3);
Assert.AreEqual("floatAttribute3", mesh.Attributes["floatAttribute3"].Name);
Assert.AreEqual(VertexAttributeType.FloatVector3, mesh.Attributes["floatAttribute3"].Datatype);
VertexAttributeFloatVector4 floatAttribute4 = new VertexAttributeFloatVector4("floatAttribute4");
mesh.Attributes.Add(floatAttribute4);
Assert.AreEqual("floatAttribute4", mesh.Attributes["floatAttribute4"].Name);
Assert.AreEqual(VertexAttributeType.FloatVector4, mesh.Attributes["floatAttribute4"].Datatype);
///////////////////////////////////////////////////////////////////
VertexAttributeByte byteAttribute = new VertexAttributeByte("byteAttribute");
mesh.Attributes.Add(byteAttribute);
Assert.AreEqual("byteAttribute", mesh.Attributes["byteAttribute"].Name);
Assert.AreEqual(VertexAttributeType.UnsignedByte, mesh.Attributes["byteAttribute"].Datatype);
VertexAttributeRGBA colorAttribute = new VertexAttributeRGBA("colorAttribute");
mesh.Attributes.Add(colorAttribute);
Assert.AreEqual("colorAttribute", mesh.Attributes["colorAttribute"].Name);
Assert.AreEqual(VertexAttributeType.UnsignedByte, mesh.Attributes["colorAttribute"].Datatype);
colorAttribute.AddColor(Color.FromArgb(3, 0, 1, 2));
Assert.AreEqual(0, colorAttribute.Values[0]);
Assert.AreEqual(1, colorAttribute.Values[1]);
Assert.AreEqual(2, colorAttribute.Values[2]);
Assert.AreEqual(3, colorAttribute.Values[3]);
}