// Process the models.
private void ProcessModels(bool invertTextures, bool zIsUp)
{
// Make the dictionary of materials.
foreach (ObjMaterial material in AllMaterials)
{
// Make the material's MaterialGroup.
material.MatGroup = new MaterialGroup();
// Transparency. (Not used.)
byte alpha = (byte)(material.Alpha * 255);
// Diffuse.
byte diffR = (byte)(material.Kd.X * 255);
byte diffG = (byte)(material.Kd.Y * 255);
byte diffB = (byte)(material.Kd.Z * 255);
Color diffColor = Color.FromArgb(255, diffR, diffG, diffB);
SolidColorBrush diffBrush = new SolidColorBrush(diffColor);
DiffuseMaterial diffMat = new DiffuseMaterial(diffBrush);
material.MatGroup.Children.Add(diffMat);
// If it has a file, use it.
if (material.Filename != null)
{
// Use the file.
string filename = material.Filename;
ImageBrush imgBrush = new ImageBrush();
imgBrush.ViewportUnits = BrushMappingMode.Absolute;
imgBrush.TileMode = TileMode.Tile;
// Invert the texture if necessary.
if (invertTextures)
{
TransformGroup trans = new TransformGroup();
trans.Children.Add(new ScaleTransform(1, -1));
trans.Children.Add(new TranslateTransform(0, 1));
imgBrush.Transform = trans;
}
imgBrush.ImageSource = new BitmapImage(new Uri(filename, UriKind.Relative));
DiffuseMaterial imgMat = new DiffuseMaterial(imgBrush);
material.MatGroup.Children.Add(imgMat);
}
// Specular.
byte specR = (byte)(material.Ks.X * 255);
byte specG = (byte)(material.Ks.Y * 255);
byte specB = (byte)(material.Ks.Z * 255);
Color specColor = Color.FromArgb(255, specR, specG, specB);
SolidColorBrush specBrush = new SolidColorBrush(specColor);
SpecularMaterial specMat = new SpecularMaterial(specBrush, material.Ns);
material.MatGroup.Children.Add(specMat);
// We ignore Ka and Tr.
// Add it to the materials dictionary.
MtlMaterials.Add(material.Name, material);
}
// Convert the object models into meshes.
foreach (ObjModel model in AllObjectModels)
{
// Make the mesh.
MeshGeometry3D mesh = new MeshGeometry3D();
Meshes.Add(mesh);
MeshNames.Add(model.Name);
MaterialNames.Add(model.MaterialName);
// Make a new list of smoothing groups.
Dictionary <int, Dictionary <Point3D, int> > smoothingGroups =
new Dictionary <int, Dictionary <Point3D, int> >();
// Entry 0 is null (no smoothing).
smoothingGroups.Add(0, null);
// Make the faces.
foreach (ObjFace face in model.Faces)
{
// Make the face's vertices.
int numPoints = face.Vertices.Count;
Point3D[] points = new Point3D[numPoints];
for (int i = 0; i < numPoints; i++)
{
points[i] = AllVertices[face.Vertices[i] - 1];
}
// Get texture coordinates if present.
Point[] textureCoords = null;
if (face.TextureCoords.Count > 0)
{
textureCoords = new Point[numPoints];
for (int i = 0; i < numPoints; i++)
{
textureCoords[i] = AllTextureCoordinates[face.TextureCoords[i] - 1];
}
}
// Get normals if present.
Vector3D[] normals = null;
if (face.Normals.Count > 0)
{
normals = new Vector3D[numPoints];
for (int i = 0; i < numPoints; i++)
{
normals[i] = AllNormals[face.Normals[i] - 1];
}
}
// Get the point dictionary for this smoothing group.
// Add new groups if needed.
if (!smoothingGroups.ContainsKey(face.SmoothingGroup))
{
smoothingGroups.Add(face.SmoothingGroup,
new Dictionary <Point3D, int>());
}
Dictionary <Point3D, int> pointDict = smoothingGroups[face.SmoothingGroup];
// Make the polygon.
mesh.AddPolygon(pointDict: pointDict,
textureCoords: textureCoords, normals: normals,
points: points);
}
// If Z is up, rotate the model.
if (zIsUp)
{
mesh.ApplyTransformation(D3.Rotate(D3.XVector(), D3.Origin, -90));
}
}
}
// Draw a branch in the indicated direction.
private void DrawBranch(MeshGeometry3D mesh,
int depth, double length, double radius, double angle,
double lengthFactor, double radiusFactor, int numBranches,
Point3D startPoint, Vector3D axis, int numSides)
{
// Set the branch's length.
axis = axis.Scale(length);
// Get two vectors perpendicular to the axis.
Vector3D v1;
if (Vector3D.AngleBetween(axis, D3.ZVector()) > 0.1)
{
v1 = Vector3D.CrossProduct(axis, D3.ZVector());
}
else
{
v1 = Vector3D.CrossProduct(axis, D3.XVector());
}
Vector3D v2 = Vector3D.CrossProduct(axis, v1);
v1 = v1.Scale(radius);
v2 = v2.Scale(radius);
// Make the cone's base.
Point3D[] pgon = G3.MakePolygonPoints(numSides, startPoint, v1, v2);
// Make the branch.
mesh.AddCylinder(pgon, axis, true);
// Draw child branches.
if (depth <= 0)
{
return;
}
// Move to the end of this segment.
depth--;
startPoint += axis;
length *= lengthFactor;
if (length < 0.01)
{
length = 0.01;
}
radius *= radiusFactor;
if (radius < 0.001)
{
radius = 0.001;
}
// Find child vectors.
List <Vector3D> children = axis.MakeFlowerVectors(
D3.YVector(), D3.ZVector(), angle, numBranches);
// Draw the child branches.
foreach (Vector3D child in children)
{
DrawBranch(mesh, depth, length,
radius, angle, lengthFactor, radiusFactor, numBranches,
startPoint, child, numSides);
}
}