public ExplodingMesh(MeshGeometry3D inputMesh, Point3D hitpos)
{
var mesh = MeshGeometryHelper.NoSharedVertices(inputMesh);
double cx, cy, cz;
cx = cy = cz = 0;
for (int i = 0; i < mesh.Positions.Count; i++)
{
cx += mesh.Positions[i].X;
cy += mesh.Positions[i].Y;
cz += mesh.Positions[i].Z;
}
int n = mesh.Positions.Count;
var center = new Point3D(cx / n, cy / n, cz / n);
integrator = new VerletIntegrator();
integrator.Resize(mesh.Positions.Count);
var r = new Random();
for (int i = 0; i < mesh.Positions.Count; i++)
{
var delta = mesh.Positions[i] - center;
delta.Normalize();
integrator.Positions[i] = mesh.Positions[i] + delta * (1 + r.NextDouble() * 2);
integrator.Positions0[i] = mesh.Positions[i];
integrator.Accelerations[i] = new Vector3D(0, 0, -1000);
integrator.InverseMass[i] = 0.01;
}
integrator.CreateConstraintsByMesh(mesh, 0.7);
integrator.AddFloor(0.3);
this.Mesh = mesh;
watch.Start();
}
/// <summary>
/// Calculates the texture for the specified model.
/// </summary>
/// <param name="model">
/// The model.
/// </param>
/// <param name="mesh">
/// The mesh.
/// </param>
public override void Calculate(TerrainModel model, MeshGeometry3D mesh)
{
var normals = MeshGeometryHelper.CalculateNormals(mesh);
var texcoords = new PointCollection();
var up = new Vector3D(0, 0, 1);
for (int i = 0; i < normals.Count; i++)
{
double slope = Math.Acos(Vector3D.DotProduct(normals[i], up)) * 180 / Math.PI;
double u = slope / 40;
if (u > 1)
{
u = 1;
}
if (u < 0)
{
u = 0;
}
texcoords.Add(new Point(u, u));
}
this.TextureCoordinates = texcoords;
this.Material = MaterialHelper.CreateMaterial(this.Brush);
}
public static Dictionary <Int32, SmileEdge> findNeighbours(MeshGeometry3D mesh)
{
Int32Collection edges = MeshGeometryHelper.FindEdges(mesh);
Int32Collection triangles = mesh.TriangleIndices;
Dictionary <Int32, SmileEdge> l = new Dictionary <Int32, SmileEdge>();
for (int j = 0; j < triangles.Count; j++)
{
SmileEdge v = new SmileEdge();
v.me = triangles[j];
for (int i = 1; i < edges.Count; i += 2)
{
if (edges[i - 1] == triangles[j])
{
v.neighbours.Add(edges[i]);
}
else
if (edges[i] == triangles[j])
{
v.neighbours.Add(edges[i - 1]);
}
}
if (!l.ContainsKey(v.me))
{
l.Add(v.me, v);
}
}
return(l);
}
public void Cut(Point3D position, Vector3D normal)
{
MeshGeometry3D worldMesh = ToWorldMesh();
var geo = MeshGeometryHelper.Cut(worldMesh, position, normal);
MeshGeometry3D localMesh = ToLocalMesh(geo);
//MeshGeometry3D localMesh = geo;
if (this.Content is Model3DGroup)
{
Model3DGroup g = (Model3DGroup)this.Content;
GeometryModel3D gm = (GeometryModel3D)g.Children[0];
Model3DGroup gr = new Model3DGroup();
var m = new GeometryModel3D(localMesh, gm.Material);
m.BackMaterial = MaterialHelper.CreateMaterial(Brushes.Black);
gr.Children.Add(m);
this.Content = gr;
}
else
{
GeometryModel3D gm = (GeometryModel3D)this.Content;
var m = new GeometryModel3D(localMesh, gm.Material);
m.BackMaterial = MaterialHelper.CreateMaterial(Brushes.Black);
this.Content = m;
}
}
public static ModelVisual3D AddContours(Visual3D model1, int d1, int d2, int d3, double diameter = 0.5)
{
var ContourModel = new ModelVisual3D();
Plane3D ContourPlane = null;
Action <GeometryModel3D, Transform3D> AddContours = (model, transform) =>
{
var p = ContourPlane.Position;
var n = ContourPlane.Normal;
var segments = MeshGeometryHelper
.GetContourSegments(model.Geometry as MeshGeometry3D, p, n).ToList();
var contours = MeshGeometryHelper.CombineSegments(segments, 1e-6).ToList();
foreach (var contour in contours)
{
if (contour.Count == 0)
{
continue;
}
ContourModel.Children.Add(new TubeVisual3D {
Diameter = diameter,
Path = new Point3DCollection(contour),
Fill = Brushes.White, ThetaDiv = 4
});
}
};
var bounds = Visual3DHelper.FindBounds(model1, Transform3D.Identity);
for (int i = 1; i < d3; i++)
{
ContourPlane = new Plane3D(
new Point3D(0, 0, bounds.Location.Z + bounds.Size.Z * i / d3),
new Vector3D(0, 0, 1));
Visual3DHelper.Traverse <GeometryModel3D>(model1, AddContours);
}
for (int i = 1; i < d2; i++)
{
ContourPlane = new Plane3D(
new Point3D(0, bounds.Location.Y + bounds.Size.Y * i / d2, 0),
new Vector3D(0, 1, 0));
Visual3DHelper.Traverse <GeometryModel3D>(model1, AddContours);
}
for (int i = 1; i < d1; i++)
{
ContourPlane = new Plane3D(
new Point3D(bounds.Location.X + bounds.Size.X * i / d1, 0, 0),
new Vector3D(1, 0, 0));
Visual3DHelper.Traverse <GeometryModel3D>(model1, AddContours);
}
return(ContourModel);
}
private void AddContours(GeometryModel3D model, Transform3D transform)
{
var p = ContourPlane.Position;
var n = ContourPlane.Normal;
var segments = MeshGeometryHelper.GetContourSegments(model.Geometry as MeshGeometry3D, p, n).ToList();
foreach (var contour in MeshGeometryHelper.CombineSegments(segments, 1e-6).ToList())
{
if (contour.Count == 0)
{
continue;
}
view2.Children.Add(new TubeVisual3D {
Diameter = 0.03, Path = new Point3DCollection(contour), Fill = Brushes.Green
});
}
}
internal List <GeometryModel3D> manualSegment(Point3DCollection points, Vector3DCollection vectors)
{
List <GeometryModel3D> models = new List <GeometryModel3D>();
//MeshGeometry3D worldMesh = GetMesh();//ToWorldMesh();
MeshGeometry3D worldMesh = ToWorldMesh();
for (var i = 1; i < points.Count; i++)
{
Point3D p0 = points[i - 1];
Vector3D n0 = vectors[i - 1];
Point3D pi = points[i];
Vector3D ni = vectors[i];
Point3D pp = new Point3D(0, 0, 0);
Vector3D nn = Point3D.Subtract(p0, pp);
if (i == 1)
{
nn = Point3D.Subtract(pi, pp);
}
var g1 = MeshGeometryHelper.Cut(worldMesh, pp, nn);
this.Children.Add(new RectangleVisual3D {
Origin = ToLocal(pp), Normal = nn, Fill = new SolidColorBrush(Colors.LightGoldenrodYellow), BackMaterial = MaterialHelper.CreateMaterial(new SolidColorBrush(Colors.Blue))
});
if (i > 1)
{
n0.Negate();
}
//var geo = MeshGeometryHelper.Cut(worldMesh, p0, n0);
var geo = MeshGeometryHelper.Cut(g1, p0, n0);
this.Children.Add(new RectangleVisual3D {
Origin = ToLocal(p0), Normal = n0, Fill = new SolidColorBrush(Colors.LightGoldenrodYellow), BackMaterial = MaterialHelper.CreateMaterial(new SolidColorBrush(Colors.Blue))
});
//Console.WriteLine(i+" = "+p0.ToString());
var geo1 = MeshGeometryHelper.Cut(geo, pi, ni);
this.Children.Add(new RectangleVisual3D {
Origin = ToLocal(pi), Normal = ni, Fill = new SolidColorBrush(Color.FromArgb(80, 255, 0, 0)), BackMaterial = MaterialHelper.CreateMaterial(new SolidColorBrush(Colors.Green))
});
//var geo2 = ToLocalMesh(geo1);
var model = new GeometryModel3D(geo1, MaterialHelper.CreateMaterial(TeethVisual3D.getTeethColor(i)));
models.Add(model);
}
return(models);
}
public void drawBorderEdges(MeshGeometry3D mesh)
{
Int32Collection edges = MeshGeometryHelper.FindBorderEdges(mesh);
Point3DCollection pos = mesh.Positions;
for (int i = 1; i < edges.Count; i += 2)
{
Point3DCollection paths = new Point3DCollection();
paths.Add(pos[edges[i - 1]]);
paths.Add(pos[edges[i]]);
TubeVisual3D t = new TubeVisual3D {
Diameter = 0.02, Path = paths, Fill = Brushes.Yellow
};
//t.Transform = new TranslateTransform3D(1, 1, 1);
this.Children.Add(t);
}
}
public override void Calculate(TerrainModel model, MeshGeometry3D mesh)
{
var normals = MeshGeometryHelper.CalculateNormals(mesh);
var texcoords = new PointCollection();
for (int i = 0; i < normals.Count; i++)
{
double slopedir = Math.Atan2(normals[i].Y, normals[i].X) * 180 / Math.PI;
if (slopedir < 0)
{
slopedir += 360;
}
double u = slopedir / 360;
texcoords.Add(new Point(u, u));
}
TextureCoordinates = texcoords;
Material = MaterialHelper.CreateMaterial(Brush);
}
private void AddContours(GeometryModel3D model, Transform3D transform)
{
var wPosition = ContourPlane.Position;
var wNormal = ContourPlane.Normal;
var wSegments = MeshGeometryHelper.GetContourSegments(model.Geometry as MeshGeometry3D, wPosition, wNormal).ToList();
foreach (var wContour in MeshGeometryHelper.CombineSegments(wSegments, 1e-6).ToList())
{
if (wContour.Count == 0)
{
continue;
}
HelixViewPort.Children.Add(new TubeVisual3D
{
Diameter = Properties.LineDiameter / 100,
Path = new Point3DCollection(wContour),
Fill = new SolidColorBrush(Properties.WireframeColor)
});
}
}
internal GeometryModel3D cutByPlane()
{
var p = new Point3D(0, 0, 0);
//MeshGeometry3D worldMesh = GetMesh();//ToWorldMesh();
MeshGeometry3D worldMesh = ToWorldMesh();
var n = _plane.Normal;
var nn = _plane.Normal;
nn.Negate();
nn.Normalize();
var geo = MeshGeometryHelper.Cut(worldMesh, p, nn);
//var geo1 = ToLocalMesh(geo);
var model = new GeometryModel3D(geo, MaterialHelper.CreateMaterial(Colors.Tomato));
model.BackMaterial = MaterialHelper.CreateMaterial(Colors.Bisque);
this.Cut(p, n);
showManipulator = false;
showHideManipulator();
return(model);
}
private void Timer_Tick(object sender, EventArgs e)
{
if (DynamicTexture)
{
var texture = new Vector2Collection(Model.TextureCoordinates);
for (int i = 1; i < Model.TextureCoordinates.Count; ++i)
{
texture[i - 1] = Model.TextureCoordinates[i];
}
texture[texture.Count - 1] = Model.TextureCoordinates[0];
Model.TextureCoordinates = texture;
if (ReverseInnerRotation)
{
var texture1 = new Vector2Collection(texture);
texture1.Reverse();
InnerModel.TextureCoordinates = texture1;
}
else
{
InnerModel.TextureCoordinates = texture;
}
}
if (DynamicVertices)
{
var positions = new Vector3Collection(initialPosition);
for (int i = 0; i < positions.Count; ++i)
{
positions[i] = positions[i] * (float)rnd.Next(95, 105) / 100;
}
Model.Normals = MeshGeometryHelper.CalculateNormals(positions, Model.Indices);
InnerModel.Normals = new Vector3Collection(Model.Normals.Select(x => { return(x * -1); }));
Model.Positions = positions;
InnerModel.Positions = positions;
//Alternative implementation
//Floor.DisablePropertyChangedEvent = true;
//Floor.Positions = positions;
//Floor.CalculateNormals();
//Floor.DisablePropertyChangedEvent = false;
//Floor.UpdateVertex();
}
if (DynamicTriangles)
{
var indices = new IntCollection(initialIndicies);
if (isRemoving)
{
removedIndex += 3 * 8;
if (removedIndex >= initialIndicies.Count)
{
removedIndex = initialIndicies.Count;
isRemoving = false;
}
}
else
{
removedIndex -= 3 * 8;
if (removedIndex <= 0)
{
isRemoving = true;
removedIndex = 0;
}
}
indices.RemoveRange(0, removedIndex);
Model.Indices = indices;
InnerModel.Indices = indices;
}
}
