public CrossSectionPlaneManipulator3D()
{
// corner manipulation is used to move the plane along its normal
this.cornerHandle = new MeshGeometryModel3D()
{
Geometry = NodeGeometry,
CullMode = SharpDX.Direct3D11.CullMode.Back,
};
this.cornerHandle.MouseMove3D += OnNodeMouse3DMove;
this.cornerHandle.MouseUp3D += OnNodeMouse3DUp;
this.cornerHandle.MouseDown3D += OnNodeMouse3DDown;
// edge manipulation is used to rotate the plane
this.edgeHandle = new MeshGeometryModel3D()
{
Geometry = EdgeHGeometry,
CullMode = SharpDX.Direct3D11.CullMode.Back,
};
this.edgeHandle.MouseMove3D += OnEdgeMouse3DMove;
this.edgeHandle.MouseUp3D += OnEdgeMouse3DUp;
this.edgeHandle.MouseDown3D += OnEdgeMouse3DDown;
// completing setup
this.Children.Add(cornerHandle);
this.Children.Add(edgeHandle);
CornerMaterial = DiffuseMaterials.Orange;
EdgeMaterial = DiffuseMaterials.Blue;
UpdateScaling((float)CornerScale, (float)EdgeThicknessScale, (float)SizeScale);
this.SceneNode.VisibleChanged += SceneNode_OnVisibleChanged;
}
private void Form1_Load(object sender, EventArgs e)
{
elementHost = new ElementHost
{
Dock = DockStyle.Fill
};
panel1.Controls.Add(elementHost);
viewport3DX = new HelixToolkit.Wpf.SharpDX.Viewport3DX( );
elementHost.Child = viewport3DX;
var b1 = new MeshBuilder();
b1.AddSphere(new Vector3(0, 0, 0), 0.5);
b1.AddBox(new Vector3(0, 0, 0), 1, 0.5, 2, BoxFaces.All);
MeshGeometry3D model = b1.ToMeshGeometry3D();
MeshGeometryModel3D test = new MeshGeometryModel3D
{
Material = PhongMaterials.Gold,
Geometry = model
};
var ambientLight = new AmbientLight3D
{
Color = new Color4(0.1f, 0.1f, 0.1f, 1.0f)
};
var directionalLight = new DirectionalLight3D
{
Color = SharpDX.Color.White,
Direction = new Vector3(-2, -5, -2)
};
viewport3DX.Items.Add(ambientLight);
viewport3DX.Items.Add(directionalLight);
//test.Attach( viewport3DX );
viewport3DX.Items.Add(test);
}
private void AddTransparentMesh(object o)
{
var model = new MeshGeometryModel3D();
int val = rnd.Next(0, 2);
switch (val)
{
case 0:
model.Geometry = SphereModel;
break;
case 1:
model.Geometry = BoxModel;
break;
case 2:
model.Geometry = ConeModel;
break;
}
val = rnd.Next(0, materialCollection.Count - 1);
var material = materialCollection[val];
var diffuse = material.DiffuseColor;
diffuse.Alpha = (float)rnd.Next(20, 60) / 100f;
material.DiffuseColor = diffuse;
model.Material = material;
model.Transform = new Media3D.TranslateTransform3D((float)rnd.Next(10, 100) / 10, (float)rnd.Next(10, 100) / 10, (float)rnd.Next(10, 100) / 10);
model.IsTransparent = true;
TransparentGroupModelSource.Add(model);
}
public MainWindow(String[] filepath)
{
InitializeComponent();
Rect3D initView = new Rect3D(new Point3D(0, 0, 0), new Size3D(100, 100, 100));
ResetCameraPosition(initView);
LoadModel(".\\SetupParts\\articulator2.stl");
LoadModel(".\\SetupParts\\calibratePart.stl");
for (int i = 0; i != filepath.Length; ++i)
{
int isload = LoadModel(filepath[i]);
if (isload == 0)
{
MeshGeometryModel3D bones = ModelGroup.Children[2 + i] as MeshGeometryModel3D;
PhongMaterial bones_material = bones.Material as PhongMaterial;
bones_material.DiffuseColor = SharpDX.Color.Gray;
}
MessageBox.Show(filepath[i]);
MessageBox.Show(isload.ToString());
}
MeshGeometryModel3D model = ModelGroup.Children[1] as MeshGeometryModel3D;
PhongMaterial m = model.Material as PhongMaterial;
m.DiffuseColor = SharpDX.Color.Red;
}
private static List <MeshGeometryModel3D> GenerateMeshGeometryModels(MGEOFile mgeo)
{
List <MeshGeometryModel3D> models = new List <MeshGeometryModel3D>(mgeo.Objects.Count);
foreach (MGEOObject mgeoModel in mgeo.Objects)
{
IntCollection indices = new IntCollection(mgeoModel.Indices.Select(x => (int)x).AsEnumerable());
Vector3Collection vertices = new Vector3Collection(mgeoModel.Vertices.Count);
Vector2Collection uvs = new Vector2Collection(mgeoModel.Vertices.Count);
foreach (MGEOVertex vertex in mgeoModel.Vertices)
{
vertices.Add(new dxVector3(vertex.Position.X, vertex.Position.Y, vertex.Position.Z));
uvs.Add(new dxVector2(vertex.DiffuseUV.X, vertex.DiffuseUV.Y));
}
MeshGeometry3D meshGeometry = new MeshGeometry3D()
{
Indices = indices,
Positions = vertices,
TextureCoordinates = uvs
};
MeshGeometryModel3D model = new MeshGeometryModel3D()
{
Geometry = meshGeometry,
Material = DiffuseMaterials.Pearl,
Name = mgeoModel.Name
};
models.Add(model);
}
return(models);
}
/// <summary>
/// Remove object highlight after deselection.
/// </summary>
/// <param name="oldSelection"></param>
private void removeHighlight(Element3D oldSelection)
{
// remove highlight from meshes
MeshGeometryModel3D meshSel = oldSelection as MeshGeometryModel3D;
meshSel.PostEffects = null;
}
public CurvatureViewModel()
{
Camera.LookDirection = new Vector3D(-100, -65, -180);
Camera.Position = (Point3D)(-Camera.LookDirection + new Vector3D(0, 0, 50));
Items.Add(_refLines = new LineGeometryModel3D {
Color = Colors.White,
Smoothness = 0.7
});
Items.Add(new LineGeometryModel3D {
Color = Colors.Gray,
Smoothness = 0.7,
Geometry = BuildGrid()
});
var mat = PhongMaterials.Brass.CloneMaterial();
mat.DiffuseColor = new Color4((Color3)mat.DiffuseColor, 0.9f);
Items.Add(_model = new MeshGeometryModel3D {
Material = mat,
CullMode = CullMode.Back
});
mat = mat.CloneMaterial();
mat.DiffuseColor = new Color4(1, 0, 0, 0.5f);
Items.Add(_deflectionModel = new MeshGeometryModel3D {
Material = mat,
CullMode = CullMode.Back
});
}
public static MeshGeometryModel3D MakeMeshGeometryModel3DUnity(DHTriangle triangle, HelixToolkit.Wpf.SharpDX.Material mat)
{
var allIndices = new List <int>(new int[] { 0, 1, 2 });
var g3d = new HelixToolkit.Wpf.SharpDX.MeshGeometry3D();
g3d.Positions = new HelixToolkit.Wpf.SharpDX.Core.Vector3Collection();
g3d.TriangleIndices = new HelixToolkit.Wpf.SharpDX.Core.IntCollection();
g3d.Normals = new HelixToolkit.Wpf.SharpDX.Core.Vector3Collection();
g3d.Indices = new HelixToolkit.Wpf.SharpDX.Core.IntCollection();
g3d.Positions.Add(U2V(triangle.vertices0));
g3d.Positions.Add(U2V(triangle.vertices1));
g3d.Positions.Add(U2V(triangle.vertices2));
g3d.Normals.Add(new SharpDX.Vector3(0, 1, 0));
g3d.Normals.Add(new SharpDX.Vector3(0, 1, 0));
g3d.Normals.Add(new SharpDX.Vector3(0, 1, 0));
for (int i = 0; i < allIndices.Count; i++)
{
g3d.Indices.Add(allIndices[i]);
}
var ret = new MeshGeometryModel3D();
ret.Material = mat;
ret.Geometry = g3d;
//ret. = new System.Windows.Controls.TextBlock() { Text = caption };
return(ret);
}
public static MeshGeometryModel3D MakeMeshGeometryModel3D(List <Point3D> allPoints, HelixToolkit.Wpf.SharpDX.Material mat)
{
var allIndices = new List <int>();
for (int i = 0; i < allPoints.Count; i++)
{
allIndices.Add(i);
}
var g3d = new HelixToolkit.Wpf.SharpDX.MeshGeometry3D();
g3d.Positions = new HelixToolkit.Wpf.SharpDX.Core.Vector3Collection();
g3d.TriangleIndices = new HelixToolkit.Wpf.SharpDX.Core.IntCollection();
g3d.Normals = new HelixToolkit.Wpf.SharpDX.Core.Vector3Collection();
g3d.Indices = new HelixToolkit.Wpf.SharpDX.Core.IntCollection();
for (int i = 0; i < allPoints.Count; i++)
{
var p3 = allPoints[i];
SharpDX.Vector3 v3 = P2V(p3);
g3d.Positions.Add(v3);
g3d.Normals.Add(new SharpDX.Vector3(0, 1, 0));
}
for (int i = 0; i < allIndices.Count; i++)
{
g3d.Indices.Add(allIndices[i]);
}
var ret = new MeshGeometryModel3D();
ret.Material = mat;
ret.Geometry = g3d;
//ret. = new System.Windows.Controls.TextBlock() { Text = caption };
return(ret);
}
private void OnWorldGenerated(object sender, EventArgs args)
{
var world = (World)sender;
WorldMeshes = new GroupModel3D();
world.Voxels.ToList().ForEach(vox =>
{
var voxel = (Voxel)vox;
CubeFace face;
MeshBuilder b = new MeshBuilder();
voxel.GetVisibleCubeFaces().ForEach(f =>
{
if (voxel.Faces.TryGetValue(f, out face))
{
b.AddCubeFace(face.CubeCenter, face.Normal, face.Up, face.Distance, face.Width, face.Height);
}
});
var mm = b.ToMesh();
var simHelper = new MeshSimplification(mm);
int size = mm.Indices.Count / 3 / 2;
var m = simHelper.Simplify(size, 7, true, true);
var mesh = new MeshGeometryModel3D
{
Geometry = mm,
CullMode = SharpDX.Direct3D11.CullMode.Back
};
var scale = new ScaleTransform3D(1, 1, 1);
var translate = new TranslateTransform3D(0, 0, 0);
var group = new Transform3DGroup();
group.Children.Add(scale);
group.Children.Add(translate);
mesh.Transform = group;
mesh.Material = voxel.PhysicalMaterial;
if (((Engine.Core.World.Material)voxel.Material).PhysicalMaterial.DiffuseColor.Alpha < 1)
{
mesh.IsTransparent = true;
}
WorldMeshes.Children.Add(mesh);
voxel.Mesh = mesh;
});
//Viewport = InitializeViewport();
//while (Viewport == null) { Debug.WriteLine($"Waiting for Viewport..."); }
}
public BoxManipulator3D()
{
facesGroup = new GroupModel3D();
var mb = new MeshBuilder();
mb.AddFaceNX();
negX = CreateMesh(mb);
mb = new MeshBuilder();
mb.AddFaceNY();
negY = CreateMesh(mb);
mb = new MeshBuilder();
mb.AddFaceNZ();
negZ = CreateMesh(mb);
mb = new MeshBuilder();
mb.AddFacePX();
posX = CreateMesh(mb);
mb = new MeshBuilder();
mb.AddFacePY();
posY = CreateMesh(mb);
mb = new MeshBuilder();
mb.AddFacePZ();
posZ = CreateMesh(mb);
negX.Mouse3DDown += Manipulation_Mouse3DDown;
negY.Mouse3DDown += Manipulation_Mouse3DDown;
negZ.Mouse3DDown += Manipulation_Mouse3DDown;
posX.Mouse3DDown += Manipulation_Mouse3DDown;
posY.Mouse3DDown += Manipulation_Mouse3DDown;
posZ.Mouse3DDown += Manipulation_Mouse3DDown;
negX.Mouse3DMove += Manipulation_Mouse3DMove;
negY.Mouse3DMove += Manipulation_Mouse3DMove;
negZ.Mouse3DMove += Manipulation_Mouse3DMove;
posX.Mouse3DMove += Manipulation_Mouse3DMove;
posY.Mouse3DMove += Manipulation_Mouse3DMove;
posZ.Mouse3DMove += Manipulation_Mouse3DMove;
negX.Mouse3DUp += Manipulation_Mouse3DUp;
negY.Mouse3DUp += Manipulation_Mouse3DUp;
negZ.Mouse3DUp += Manipulation_Mouse3DUp;
posX.Mouse3DUp += Manipulation_Mouse3DUp;
posY.Mouse3DUp += Manipulation_Mouse3DUp;
posZ.Mouse3DUp += Manipulation_Mouse3DUp;
facesGroup.Children.Add(negX);
facesGroup.Children.Add(negY);
facesGroup.Children.Add(negZ);
facesGroup.Children.Add(posX);
facesGroup.Children.Add(posY);
facesGroup.Children.Add(posZ);
Children.Add(facesGroup);
}
private void AddGroupModel(object o)
{
var model = new MeshGeometryModel3D();
model.Geometry = SphereModel;
model.Material = BlueMaterial;
model.Transform = new Media3D.TranslateTransform3D(0, (GroupModelSource.Count + 1) * 2, 0);
GroupModelSource.Add(model);
}
private void OnModelSelected(MeshGeometryModel3D model)
{
if (_selectedIfcItem != null)
{
FillMeshByIfcColor(_selectedIfcItem);
_selectedIfcItem = null;
}
Redraw();
}
public Watch3DxControl()
{
InitializeComponent();
// DataContext = this;
// titles
view1.Title = "Watch3DxNode";
view1.SubTitle = "SharpDX";
// camera setup
view1.Camera = new PerspectiveCamera
{
Position = new Point3D(3, 3, 5),
LookDirection = new Vector3D(-3, -3, -5),
UpDirection = new Vector3D(0, 1, 0),
FarPlaneDistance = 5000000
};
// default render technique
view1.RenderTechniquesManager = new DefaultRenderTechniquesManager();
view1.RenderTechnique = view1.RenderTechniquesManager.RenderTechniques[DefaultRenderTechniqueNames.Phong];
view1.EffectsManager = new DefaultEffectsManager(view1.RenderTechniquesManager);
// Setup lights
var directionalLight3D = new DirectionalLight3D
{
Color = Color.White,
Direction = new Vector3(-2, -5, -2)
};
var ambientLight3D = new AmbientLight3D {
Color = Color.White
};
view1.Items.Add(ambientLight3D);
view1.Items.Add(directionalLight3D);
// Geometry
var mb = new MeshBuilder();
mb.AddSphere(new Vector3(0, 0, 0), 0.5);
mb.AddBox(new Vector3(0, 0, 0), 1, 0.5, 2, BoxFaces.All);
var meshGeometry = mb.ToMeshGeometry3D();
var meshGeomModel = new MeshGeometryModel3D
{
Geometry = meshGeometry,
Material = PhongMaterials.Red
};
// Add the Model to the viewport
view1.Items.Add(meshGeomModel);
}
private void CreateFaceModels(IFCItem item, Vector3D center)
{
while (item != null)
{
if (item.ifcID != IntPtr.Zero && item.noVerticesForFaces != 0 && item.noPrimitivesForFaces != 0)
{
var positions = new List <Vector3>();
var normals = new List <Vector3>();
if (item.verticesForFaces != null)
{
for (int i = 0; i < item.noVerticesForFaces; i++)
{
var point = new Point3D(item.verticesForFaces[6 * i + 0] - center.X, item.verticesForFaces[6 * i + 1] - center.Y, item.verticesForFaces[6 * i + 2] - center.Z);
var normal = new Vector3D(item.verticesForFaces[6 * i + 3], item.verticesForFaces[6 * i + 4], item.verticesForFaces[6 * i + 5]);
positions.Add(new Vector3((float)point.X, (float)point.Y, (float)point.Z));
normals.Add(new Vector3((float)normal.X, (float)normal.Y, (float)normal.Z));
}
Debug.Assert(item.verticesForFaces.Length == item.noVerticesForFaces * 6);
}
var indices = new Int32Collection();
if (item.indicesForFaces != null)
{
for (int i = 0; i < 3 * item.noPrimitivesForFaces; i++)
{
indices.Add(item.indicesForFaces[i]);
}
}
List <Vector2> textureCoords = positions.Select(o => new Vector2(o.X, o.Y)).ToList();
var meshBuilder = new MeshBuilder();
meshBuilder.Append(positions, indices, normals, textureCoords);
MeshGeometryModel3D mesh = new MeshGeometryModel3D()
{
Geometry = meshBuilder.ToMeshGeometry3D()
};
item.Mesh3d = mesh;
_meshToIfcItems[mesh] = item;
#if DEBUG
//OutputObj(item.ifcID.ToString(), mesh);
#endif
FillMeshByIfcColor(item);
model.Add(mesh);
}
CreateFaceModels(item.child, center);
item = item.next;
}
}
/// <summary>
/// Highlight selected object.
/// </summary>
private void highlightSelection()
{
foreach (Element3D ele in selection)
{
Type objectType = ele.GetType();
// highlight meshes
if (objectType == typeof(MeshGeometryModel3D))
{
MeshGeometryModel3D meshSel = ele as MeshGeometryModel3D;
meshSel.PostEffects = "borderHighlight";
}
}
}
public void AttachModelList(List <Object3D> objs)
{
this.ModelGeometry = new Element3DCollection();
foreach (var ob in objs)
{
var s = new MeshGeometryModel3D
{
Geometry = ob.Geometry,
Material = ob.Material,
};
this.ModelGeometry.Add(s);
}
this.OnPropertyChanged("ModelGeometry");
}
public static RenderModel3D Error(string name)
{
var element = new MeshGeometryModel3D
{
Geometry = errorGeometry,
Material = errorMaterial
};
var model = new RenderModel3D(name, Enumerable.Empty <Region>(), Enumerable.Empty <InstanceGroup>());
model.Children.Add(element);
return(model);
}
public void SetModelMaterial(MeshGeometryModel3D model)
{
PhongMaterial material = new PhongMaterial
{
ReflectiveColor = SharpDX.Color.Black,
AmbientColor = new SharpDX.Color(0.0f, 0.0f, 0.0f, 1.0f),
EmissiveColor = SharpDX.Color.Black,
SpecularColor = new SharpDX.Color(90, 90, 90, 255),
SpecularShininess = 60,
DiffuseColor = SharpDX.Color.Blue
};
model.Material = material;
}
private void BuildPlanes()
{
PlaneGeometry = new ObservableElement3DCollection();
var builder = new MeshBuilder(true);
builder.AddBox(new SharpDX.Vector3(0, 0, 0), 15, 15, 0.5);
var mesh = builder.ToMesh();
var material = new PhongMaterial();
material.DiffuseColor = new SharpDX.Color4(1, 0, 0, 0.5f);
var model = new MeshGeometryModel3D()
{
Geometry = mesh,
Material = material,
Transform = new Media3D.TranslateTransform3D(-15, 0, 0),
IsTransparent = true,
CullMode = SharpDX.Direct3D11.CullMode.Back
};
PlaneGeometry.Add(model);
material = new PhongMaterial();
material.DiffuseColor = new SharpDX.Color4(0, 1, 0, 0.5f);
model = new MeshGeometryModel3D()
{
Geometry = mesh,
Material = material,
Transform = new Media3D.TranslateTransform3D(-20, 5, -10),
IsTransparent = true,
CullMode = SharpDX.Direct3D11.CullMode.Back
};
PlaneGeometry.Add(model);
material = new PhongMaterial();
material.DiffuseColor = new SharpDX.Color4(0, 0, 1, 0.5f);
model = new MeshGeometryModel3D()
{
Geometry = mesh,
Material = material,
Transform = new Media3D.TranslateTransform3D(-25, 10, -20),
IsTransparent = true,
CullMode = SharpDX.Direct3D11.CullMode.Back
};
PlaneGeometry.Add(model);
}
public void Setup()
{
closePoint = InitializePointWithId("closePoint");
farPoint = InitializePointWithId("farPoint", new Vector3(10000, 10000, 10000));
var builder = new MeshBuilder();
builder.AddBox(new Vector3(-10000, -10000, -5000), 5, 5, 5, BoxFaces.All);
var boxGeom = builder.ToMeshGeometry3D();
cube = new MeshGeometryModel3D()
{
Geometry = boxGeom,
Name = "cube"
};
}
/// <summary>
/// previews the material of a particular element.
/// used within the previewSelectionMaterial function
/// </summary>
private void previewElementMaterial(MeshGeometryModel3D element)
{
// get the mesh
MeshGeometryModel3D meshSel = element as MeshGeometryModel3D;
// get data context
if (element.DataContext.GetType() == typeof(cubeDataModel))
{
// get the pdm
cubeDataModel pdm = element.DataContext as cubeDataModel;
// assign the color
//pdm.panelMaterial = (selectedPanelMaterial != projectMaterials.None) ? selectedPanelMaterial : pdm.panelMaterial;
meshSel.Material = (selectedPanelMaterial != projectMaterials.None) ? projectMatToHelixMatConverter.Convert(selectedPanelMaterial) as Material : projectMatToHelixMatConverter.Convert(pdm.material) as Material;
}
}
public void CreateDefaultVertexArrayForTriangle()
{
var reader = new ObjReader();
var objects = reader.Read(@"Models\obj\Triangle.obj");
Assert.AreEqual(1, objects.Count);
var geometry = objects[0].Geometry;
var model = new MeshGeometryModel3D { Geometry = geometry };
var canvas = new CanvasMock();
model.Attach(canvas);
Assert.AreEqual(true, model.IsAttached);
}
private MeshGeometryModel3D CreateBall(HelixToolkit.Wpf.SharpDX.Material mat)
{
MeshGeometryModel3D mgm = new MeshGeometryModel3D();
MeshBuilder mb = new MeshBuilder();
//mb.AddSphere(MapReader.P2V(p), 2);
mb.AddSphere(Vector3.Zero, 0.5);
//mb.AddArrow(Vector3.Zero, new Vector3(0, 0, 2), 0.1);
mgm.Geometry = mb.ToMeshGeometry3D();
mgm.Material = mat;
mViewModel.PlayersGeometry.Add(mgm);
mgm.Attach(mViewModel.modelView.RenderHost);
return(mgm);
}
public void AttachModelList(List <Object3D> objs)
{
this.ModelTransform = new TranslateTransform3D(0, 0, 0);
this.ModelGeometry = new Element3DCollection();
foreach (var ob in objs)
{
var s = new MeshGeometryModel3D
{
Geometry = ob.Geometry,
Material = ob.Material,
};
this.ModelGeometry.Add(s);
s.Attach(modelView.RenderHost);
}
this.OnPropertyChanged("ModelGeometry");
}
private void OnNodeMouse3DMove(object sender, RoutedEventArgs e)
{
if (this._isCaptured)
{
Application.Current.MainWindow.Cursor = Cursors.Hand;
var args = e as Mouse3DEventArgs;
var normal = this._camera.LookDirection;
var newHit = this._viewport.UnProjectOnPlane(args.Position, _lastHitPos, normal);
if (newHit.HasValue)
{
MeshGeometryModel3D corner = sender as MeshGeometryModel3D;
var offset = (newHit.Value - _lastHitPos);
var localTransform = corner.Transform.Value;
Matrix3D groupTransform = this.Transform.Value;
groupTransform.Invert();
offset = groupTransform.Transform(offset);
//將w正規化為1
if (this.DragX)
{
localTransform.OffsetX += offset.X / groupTransform.M44;
}
if (this.DragY)
{
localTransform.OffsetY += offset.Y / groupTransform.M44;
}
if (this.DragZ)
{
localTransform.OffsetZ += offset.Z / groupTransform.M44;
}
this._lastHitPos = newHit.Value;
corner.Transform = new MatrixTransform3D(localTransform);
}
UpdateTransforms();
}
}
/// <summary>
/// Reverts any temporary material previews upon deselection
/// </summary>
private void revertMaterial(Element3D oldSelection)
{
// remove any temp preview colors
Type objectType = oldSelection?.GetType();
if (objectType == typeof(MeshGeometryModel3D))
{
MeshGeometryModel3D meshSel = oldSelection as MeshGeometryModel3D;
if (oldSelection.DataContext.GetType() == typeof(cubeDataModel))
{
// get the pdm
cubeDataModel pdm = oldSelection.DataContext as cubeDataModel;
// reset the color
meshSel.Material = projectMatToHelixMatConverter.Convert(pdm.material) as Material;
}
}
}
public static void OutputObj(string ifcId, MeshGeometryModel3D rep)
{
using (var writer = new StreamWriter("./" + ifcId + ".obj"))
{
for (int i = 0, count = rep.Geometry.Positions.Count; i < count; i++)
{
writer.WriteLine("v {0} {1} {2}", rep.Geometry.Positions[i].X, rep.Geometry.Positions[i].Y, rep.Geometry.Positions[i].Z);
}
List <int> dummyList = rep.Geometry.Indices;
dummyList.Reverse();
var indices = dummyList;//HACK winding
for (int i = 0, count = indices.Count / 3; i < count; i++)
{
writer.WriteLine("f {0}//{0} {1}//{1} {2}//{2}", indices[i * 3] + 1, indices[i * 3 + 1] + 1, indices[i * 3 + 2] + 1);
}
}
}
public void CreateDefaultVertexArrayForTriangle()
{
var reader = new ObjReader();
var objects = reader.Read(@"Models\obj\Triangle.obj");
Assert.AreEqual(1, objects.Count);
var geometry = objects[0].Geometry;
var model = new MeshGeometryModel3D {
Geometry = geometry
};
var canvas = new CanvasMock();
model.Attach(canvas);
Assert.AreEqual(true, model.IsAttached);
}
public HelixMeshPoser(RobotSystem robot, PBRMaterial material, ObservableElement3DCollection robotModels)
{
_default = robot.DefaultPose;
_robotModels = robotModels;
foreach (var joint in _default.Meshes.SelectMany(m => m))
{
var model = new MeshGeometryModel3D
{
Geometry = ToWPF(joint),
Material = material,
Transform = Transform3D.Identity,
IsThrowingShadow = true
};
robotModels.Add(model);
}
}
public void CreateDefaultVertexArrayForTriangle()
{
var reader = new ObjReader();
var objects = reader.Read(Path.Combine(TestContext.CurrentContext.TestDirectory, @"Models\obj\Triangle.obj"));
Assert.AreEqual(1, objects.Count);
var geometry = objects[0].Geometry;
var model = new MeshGeometryModel3D {
Geometry = geometry
};
var canvas = new CanvasMock();
model.SceneNode.Attach(canvas.RenderHost);
Assert.AreEqual(true, model.IsAttached);
}
