// Define the model. private void DefineModel() { // Axes. //MainGroup.Children.Add(MeshExtensions.XAxisModel(4, 0.1)); //MainGroup.Children.Add(MeshExtensions.YAxisModel(4, 0.1)); //MainGroup.Children.Add(MeshExtensions.ZAxisModel(4, 0.1)); //MainGroup.Children.Add(MeshExtensions.OriginModel(0.12)); // Make the ground. MeshGeometry3D groundMesh = new MeshGeometry3D(); const double dx = 4; const double dy = 1; const double dz = dx; const double groundY = -2; Point3D corner = new Point3D(-dx / 2, groundY - dy, -dz / 2); Point[] topCoords = { new Point(0, 0), new Point(0, dz), new Point(dx, dz), new Point(dx, 0), }; Point[] sideCoords = { new Point(0, 0), new Point(0, dz), new Point(dy, dz), new Point(dy, 0), }; groundMesh.AddBox(corner, D3.XVector(dx), D3.YVector(dy), D3.ZVector(dz), sideCoords, sideCoords, sideCoords, sideCoords, topCoords, topCoords); MainGroup.Children.Add(groundMesh.MakeModel("metal.jpg")); // This group represents the whole robot. RobotGroup = new Model3DGroup(); MainGroup.Children.Add(RobotGroup); // Base. const double baseWidth = 0.4; const double baseLength = 2.5; MeshGeometry3D baseMesh = new MeshGeometry3D(); baseMesh.AddBox(new Point3D(-baseWidth / 2, 0, -baseWidth / 2), D3.XVector(baseWidth), D3.YVector(baseLength), D3.ZVector(baseWidth)); GeometryModel3D baseModel = baseMesh.MakeModel(Brushes.Pink); const int numCyl = 20; const double bJointWidth = 0.5; const double bJointRadius = 0.5; Point3D[] bPgon = G3.MakePolygonPoints(numCyl, new Point3D(0, 0, 0), D3.XVector(bJointRadius), D3.ZVector(-bJointRadius)); baseMesh.AddCylinder(bPgon, D3.YVector(bJointWidth), true); BaseGroup = JoinBones(RobotGroup, new TranslateTransform3D(0, groundY, 0)); BaseGroup.Children.Add(baseModel); // Shoulder. const double shoulderWidth = 0.4; const double shoulderLength = 2; MeshGeometry3D shoulderMesh = new MeshGeometry3D(); shoulderMesh.AddBox(new Point3D(-shoulderWidth / 2, 0, -shoulderWidth / 2), D3.XVector(shoulderWidth), D3.YVector(shoulderLength), D3.ZVector(shoulderWidth)); const double sJointWidth = 0.5; const double sJointRadius = 0.4; Point3D[] sPgon = G3.MakePolygonPoints(numCyl, new Point3D(0, 0, -sJointWidth / 2), D3.XVector(sJointRadius), D3.YVector(sJointRadius)); shoulderMesh.AddCylinder(sPgon, D3.ZVector(sJointWidth), true); GeometryModel3D shoulderModel = shoulderMesh.MakeModel(Brushes.LightGreen); ShoulderGroup = JoinBones(BaseGroup, new TranslateTransform3D(0, baseLength, 0)); ShoulderGroup.Children.Add(shoulderModel); // Elbow. const double elbowWidth = 0.4; const double elbowLength = 1.5; MeshGeometry3D elbowMesh = new MeshGeometry3D(); elbowMesh.AddBox(new Point3D(-elbowWidth / 2, 0, -elbowWidth / 2), D3.XVector(elbowWidth), D3.YVector(elbowLength), D3.ZVector(elbowWidth)); const double eJointWidth = 0.5; const double eJointRadius = 0.4; Point3D[] ePgon = G3.MakePolygonPoints(numCyl, new Point3D(0, 0, -eJointWidth / 2), D3.XVector(eJointRadius), D3.YVector(eJointRadius)); elbowMesh.AddCylinder(ePgon, D3.ZVector(eJointWidth), true); GeometryModel3D elbowModel = elbowMesh.MakeModel(Brushes.LightBlue); ElbowGroup = JoinBones(ShoulderGroup, new TranslateTransform3D(0, shoulderLength, 0)); ElbowGroup.Children.Add(elbowModel); // Wrist. const double wDx = 1.5; const double wDy = 0.2; const double wDz = 0.4; MeshGeometry3D wristMesh = new MeshGeometry3D(); wristMesh.AddBox(new Point3D(-wDx / 2, 0, -wDz / 2), D3.XVector(wDx), D3.YVector(wDy), D3.ZVector(wDz)); const double wJointRadius = 0.3; Point3D[] wPgon = G3.MakePolygonPoints(numCyl, new Point3D(0, -wDy / 2, 0), D3.XVector(wJointRadius), D3.ZVector(-wJointRadius)); wristMesh.AddCylinder(wPgon, D3.YVector(wDy), true); GeometryModel3D wristModel = wristMesh.MakeModel(Brushes.Red); WristGroup = JoinBones(ElbowGroup, new TranslateTransform3D(0, elbowLength, 0)); WristGroup.Children.Add(wristModel); // Finger 1. const double fDx = 0.1; const double fDy = 0.5; const double fDz = 0.2; MeshGeometry3D finger1Mesh = new MeshGeometry3D(); finger1Mesh.AddBox(new Point3D(-fDx / 2, 0, -fDz / 2), D3.XVector(fDx), D3.YVector(fDy), D3.ZVector(fDz)); GeometryModel3D finger1Model = finger1Mesh.MakeModel(Brushes.Green); Finger1Group = JoinBones(WristGroup, new TranslateTransform3D(-fDx / 2, wDy, 0)); Finger1Group.Children.Add(finger1Model); // Finger 2. MeshGeometry3D finger2Mesh = new MeshGeometry3D(); finger2Mesh.AddBox(new Point3D(-fDx / 2, 0, -fDz / 2), D3.XVector(fDx), D3.YVector(fDy), D3.ZVector(fDz)); GeometryModel3D finger2Model = finger2Mesh.MakeModel(Brushes.Green); Finger2Group = JoinBones(WristGroup, new TranslateTransform3D(fDx / 2, wDy, 0)); Finger2Group.Children.Add(finger2Model); }
private void elbowSlider_ValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e) { ElbowGroup.Transform = D3.Rotate(D3.ZVector(), D3.Origin, elbowSlider.Value); }
private void wristSlider_ValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e) { WristGroup.Transform = D3.Rotate(D3.YVector(), D3.Origin, wristSlider.Value); }
// 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)); } } }