// GJK using Voronoi regions (Christer Ericson) and Barycentric coordinates. /// <summary> /// Initialize the proxy using the given shape. The shape /// must remain in scope while the proxy is in use. /// </summary> /// <param name="shape">The shape.</param> /// <param name="index">The index.</param> public DistanceProxy(Shape shape, int index) { Vertices = new Vertices(); switch (shape.ShapeType) { case ShapeType.Circle: { CircleShape circle = (CircleShape)shape; Vertices.Clear(); Vertices.Add(circle.Position); Radius = circle.Radius; } break; case ShapeType.Polygon: { PolygonShape polygon = (PolygonShape)shape; Vertices.Clear(); for (int i = 0; i < polygon.Vertices.Count; i++) { Vertices.Add(polygon.Vertices[i]); } Radius = polygon.Radius; } break; case ShapeType.Chain: { ChainShape chain = (ChainShape)shape; Debug.Assert(0 <= index && index < chain.Vertices.Count); Vertices.Clear(); Vertices.Add(chain.Vertices[index]); Vertices.Add(index + 1 < chain.Vertices.Count ? chain.Vertices[index + 1] : chain.Vertices[0]); Radius = chain.Radius; } break; case ShapeType.Edge: { EdgeShape edge = (EdgeShape)shape; Vertices.Clear(); Vertices.Add(edge.Vertex1); Vertices.Add(edge.Vertex2); Radius = edge.Radius; } break; default: Radius = 0; Debug.Assert(false); break; } }
// GJK using Voronoi regions (Christer Ericson) and Barycentric coordinates. /// <summary> /// Initialize the proxy using the given shape. The shape /// must remain in scope while the proxy is in use. /// </summary> /// <param name="shape">The shape.</param> /// <param name="index">The index.</param> public void Set(Shape shape, int index) { switch (shape.ShapeType) { case ShapeType.Circle: { var circle = (CircleShape)shape; vertices.Clear(); vertices.Add(circle.Position); radius = circle.Radius; } break; case ShapeType.Polygon: { var polygon = (PolygonShape)shape; vertices.Clear(); for (int i = 0; i < polygon.Vertices.Count; i++) { vertices.Add(polygon.Vertices[i]); } radius = polygon.Radius; } break; case ShapeType.Chain: { var chain = (ChainShape)shape; Debug.Assert(0 <= index && index < chain.Vertices.Count); vertices.Clear(); vertices.Add(chain.Vertices[index]); vertices.Add(index + 1 < chain.Vertices.Count ? chain.Vertices[index + 1] : chain.Vertices[0]); radius = chain.Radius; } break; case ShapeType.Edge: { var edge = (EdgeShape)shape; vertices.Clear(); vertices.Add(edge.Vertex1); vertices.Add(edge.Vertex2); radius = edge.Radius; } break; default: Debug.Assert(false); break; } }
/// <summary> /// Initialize the proxy using the given shape. The shape /// must remain in scope while the proxy is in use. /// </summary> /// <param name="shape">The shape.</param> /// <param name="index">The index.</param> public void Set(Shape shape, int index) { switch (shape.ShapeType) { case ShapeType.Circle: { CircleShape circle = (CircleShape)shape; Vertices.Clear(); Vertices.Add(circle.Position); Radius = circle.Radius; } break; case ShapeType.Polygon: { PolygonShape polygon = (PolygonShape)shape; Vertices.Clear(); for (int i = 0; i < polygon.Vertices.Count; i++) { Vertices.Add(polygon.Vertices[i]); } Radius = polygon.Radius; } break; case ShapeType.Loop: { LoopShape loop = (LoopShape)shape; Debug.Assert(0 <= index && index < loop.Vertices.Count); Vertices.Clear(); Vertices.Add(loop.Vertices[index]); Vertices.Add(index + 1 < loop.Vertices.Count ? loop.Vertices[index + 1] : loop.Vertices[0]); Radius = loop.Radius; } break; case ShapeType.Edge: { EdgeShape edge = (EdgeShape)shape; Vertices.Clear(); Vertices.Add(edge.Vertex1); Vertices.Add(edge.Vertex2); Radius = edge.Radius; } break; default: Debug.Assert(false); break; } }
public void ComputeMesh() { Vertices.Clear(); UV.Clear(); foreach (Line l in Edges) { Vertices.Add(l.StartPoint); UV.Add(new Vector2()); } Vertices.Add(Edges.Last().EndPoint); UV.Add(new Vector2()); Triangles.Clear(); for (int i = 1; i < Vertices.Count - 1; i++) { int[] tmp = new int[3]; tmp[0] = 0; tmp[1] = i; tmp[2] = i + 1; Triangles.AddRange(tmp); } }
public void Clear() { Vertices.Clear(); HalfEdges.Clear(); Faces.Clear(); UnboundedFace = null; }
/// <summary> /// Merges vertices /// </summary> public void MergeVertices(float tolerance) { if (tolerance <= 0) { return; } OctNode root = null; List <MeshVertex> oldVertices = new List <MeshVertex>(Vertices); Vertices.Clear(); for (int i = 0; i < Triangles.Count; i++) { MeshVertex v0 = oldVertices[Triangles[i].Index0]; MeshVertex v1 = oldVertices[Triangles[i].Index1]; MeshVertex v2 = oldVertices[Triangles[i].Index2]; int i0 = InsertVertex(ref root, v0, tolerance); int i1 = InsertVertex(ref root, v1, tolerance); int i2 = InsertVertex(ref root, v2, tolerance); int mtrl = Triangles[i].MaterialIndex; Triangles[i] = new MeshTriangle(i0, i1, i2, mtrl); } }
//TODO : IT internal override Annotation Clone(IDocumentEssential owner, Page page) { if (Page == null) { PointF[] points = Vertices.ToArray(); ApplyOwner(owner); SetPage(page, true); Vertices.Clear(); Vertices.Page = page; Vertices.AddRange(points); return(this); } PDFDictionary res = AnnotationBase.Copy(Dictionary); MarkupAnnotationBase.CopyTo(Dictionary, res); PolygonPolylineAnnotation.CopyTo(Dictionary, res, Page, page); PolylineAnnotation annot = new PolylineAnnotation(res, owner); annot.SetPage(Page, false); annot.SetPage(page, true); return(annot); }
// ============================================================================================ // Public Functions --------------------------------------------------------------------------- // ============================================================================================ public void EvaluateAll(Blob[] blobs) { // Initialize and clear vertices if (!initialized) { initialize(); } Vertices.Clear(); // Convert Blobs to GPUBlobs GPUBlob[] gpuBlobs = new GPUBlob[blobs.Length]; for (int i = 0; i < blobs.Length; i++) { Blob blob = blobs[i]; gpuBlobs[i].Pos = blob.transform.localPosition; gpuBlobs[i].Factor = blob.Factor; } // Compute shader time GPUVertices[] vertBuffer = runComputeShader(gpuBlobs); // Update vertices for marching cubes algorithm for (int x = 0; x < XCubes; x++) { for (int y = 0; y < YCubes; y++) { for (int z = 0; z < ZCubes; z++) { updateVertices(vertBuffer[x + XCubes * (y + YCubes * z)]); } } } }
} // Save public void Load(string fileName) { Vertices.Clear(); List <TempLink> tempLinks = new List <TempLink>(); XmlReader reader; reader = XmlReader.Create(fileName); while (reader.Read()) { if (reader.HasAttributes) { if (reader.Name == "Graph") { LoadGraph(reader); } else if (reader.Name == "Vertex") { LoadVertex(reader); } else if (reader.Name == "Links") { LoadLinks(reader, tempLinks); } } } // while reader.Close(); ConvertTempLinks(tempLinks); toolTip.ChangeToolTip(this); } // Load
private void FillObservableCollections() { Vertices.Clear(); Edges.Clear(); Graph.Vertices.Select(v => v.Object).ForEach(Vertices.Add); Graph.Edges.Select(v => v.Object).ForEach(Edges.Add); }
/// <summary> /// Clears all data in this mesh. /// </summary> public void Clear() { Vertices.Clear(); Normals.Clear(); UVs.Clear(); Triangles.Clear(); }
public void Clear() { Mesh.Clear(); Uvs.Clear(); Vertices.Clear(); Triangles.Clear(); }
/// <summary> /// /// </summary> /// <param name="selectRay">A ray in Xna Coords that was cast according to the viewport</param> /// <param name="add">Whether to add the selected triangle to the selection</param> public void UpdateSelectedTriangle(Ray selectRay, bool add) { if (!add) { Vertices.Clear(); Indices.Clear(); } var pos3D = selectRay.Position; var dir3D = selectRay.Direction; PositionUtil.TransformXnaCoordsToWoWCoords(ref pos3D); PositionUtil.TransformXnaCoordsToWoWCoords(ref dir3D); var ray3D = new Ray(pos3D, dir3D); var pos2D = new Vector2(pos3D.X, pos3D.Y); var dir2D = new Vector2(dir3D.X, dir3D.Y).NormalizedCopy(); var ray2D = new Ray2D(pos2D, dir2D); var closestTime = float.MaxValue; var closestVec0 = Vector3.Zero; var closestVec1 = Vector3.Zero; var closestVec2 = Vector3.Zero; foreach (var tile in _adtManager.MapTiles) { var results = new List <Index3>(); if (!tile.GetPotentialColliders(ray2D, results)) { continue; } foreach (var tri in results) { var vec0 = tile.TerrainVertices[tri.Index0]; var vec1 = tile.TerrainVertices[tri.Index1]; var vec2 = tile.TerrainVertices[tri.Index2]; float time; if (!Intersection.RayTriangleIntersect(ray3D, vec0, vec1, vec2, out time)) { continue; } if (time > closestTime) { continue; } closestTime = time; closestVec0 = vec0; closestVec1 = vec1; closestVec2 = vec2; } } if (closestTime == float.MaxValue) { return; } AddSelectedTriangle(closestVec0, closestVec1, closestVec2); }
public override long Contour(float threshold) { Stopwatch watch = new Stopwatch(); watch.Start(); if (tree == null) { Vertices.Clear(); tree = new OctreeNode(); List <VertexPositionColorNormal> vs = new List <VertexPositionColorNormal>(); tree.ConstructBase(Resolution, threshold, ref vs); tree.ClusterCellBase(threshold); //Vertices = vs.ToList(); tree.GenerateVertexBuffer(Vertices); if (Vertices.Count > 0) { VertexBuffer.SetData <VertexPositionColorNormal>(Vertices.ToArray()); } VertexCount = Vertices.Count; } OutlineLocation = 0; //ConstructTreeGrid(tree); CalculateIndexes(threshold); watch.Stop(); return(watch.ElapsedMilliseconds); }
public ObjFaceBuilder Clear() { Vertices.Clear(); Normals.Clear(); UVs.Clear(); return(this); }
public void Clear() { Vertices.Clear(); Edges.Clear(); Triangles.Clear(); VertexIndices.Clear(); }
public void Reset() { VertexValue = 0; Vertices.Clear(); Edges.Clear(); Faces.Clear(); }
public override void OnEntityTransformChanged(Transform.Component comp) { base.OnEntityTransformChanged(comp); if (_ignoreTransformChanges) { return; } // we only care about scale. base handles pos/rot if (comp == Transform.Component.Scale) { // fetch the Vertices, clear them, add our originals and scale them PolygonShape poly = Body.FixtureList[0].Shape as PolygonShape; Vertices verts = poly.Vertices; verts.Clear(); verts.AddRange(_verts); verts.Scale(Transform.Scale); poly.SetVerticesNoCopy(verts); // wake the body if it is asleep to update collisions if (!Body.IsAwake) { Body.IsAwake = true; } } }
public void SortVertices() { if (!Edges.Any()) { return; } Vertices.Clear(); List <Line> sortedLines = new List <Line>(); List <Line> edgesCopy = new List <Line>(); foreach (Line e in Edges) { Line tmp = new Line(e.StartPoint, e.EndPoint); edgesCopy.Add(tmp); } bool closed = false; Line currLine = edgesCopy.First(); Line toRemove = null; while (!closed) { foreach (Line line in edgesCopy) { //if (l.GetPoints().Contains(currLine.EndPoint)) if (containsPoint(line.GetPoints(), currLine.EndPoint, 5)) { Vector3 vtmp = line.GetPoints().Where(o => !almostEqual(o, currLine.EndPoint, 5)).First(); Line tmp = new Line(currLine.EndPoint, vtmp); toRemove = line; sortedLines.Add(tmp); currLine = tmp; break; } else { toRemove = null; } } if (toRemove == null) { break; } else { edgesCopy.Remove(toRemove); } if (edgesCopy.Count == 0) { closed = true; } } Edges = sortedLines; }
/// <summary> /// Clears all vertices, indices, bone tables, materials and strips. /// </summary> public void Clear() { BoneTable.Clear(); Vertices.Clear(); Indices.Clear(); Materials.Clear(); Strips.Clear(); }
void Clear() { VertexId = 0; LinkId = 0; LinkCount = 0; Vertices.Clear(); toolTip.ChangeToolTip(this); } // Clear
public virtual void Clear() { Vertices.Clear(); Normals.Clear(); Colors.Clear(); Lighting.Clear(); Indexes.Clear(); }
public Mesh(List <Vector3Float> v, FaceList f) { Vertices.Clear(); Vertices.AddRange(v); Faces.Clear(); Faces.AddRange(f); }
public void Clear() { Vertices.Clear(); UVs.Clear(); Indices.Clear(); Normals.Clear(); Colours.Clear(); }
/////////PARENTS FUNCTION////////// public override void Load(BinaryReader reader, int size) { if (size < 20) { isEmpty = true; return; } someNumber = reader.ReadUInt32(); uint triggerCount = reader.ReadUInt32(); uint groupCount = reader.ReadUInt32(); uint triCount = reader.ReadUInt32(); uint vertexCount = reader.ReadUInt32(); Triggers.Clear(); Groups.Clear(); Tris.Clear(); Vertices.Clear(); for (int i = 0; i < triggerCount; i++) { Trigger trg = new Trigger { X1 = reader.ReadSingle(), Y1 = reader.ReadSingle(), Z1 = reader.ReadSingle(), Flag1 = reader.ReadInt32(), X2 = reader.ReadSingle(), Y2 = reader.ReadSingle(), Z2 = reader.ReadSingle(), Flag2 = reader.ReadInt32() }; Triggers.Add(trg); } for (int i = 0; i < groupCount; i++) { GroupInfo grp = new GroupInfo { Size = reader.ReadUInt32(), Offset = reader.ReadUInt32() }; Groups.Add(grp); } for (int i = 0; i < triCount; i++) { ColTri tri = new ColTri(); ulong legacy = reader.ReadUInt64(); tri.Vert1 = (int)(legacy & mask); tri.Vert2 = (int)((legacy >> 18 * 1) & mask); tri.Vert3 = (int)((legacy >> 18 * 2) & mask); tri.Surface = (int)(legacy >> (18 * 3)); Tris.Add(tri); } for (int i = 0; i < vertexCount; i++) { Pos vtx = new Pos(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); Vertices.Add(vtx); } }
public virtual Vertices ToVertices() { if (_verticesInValidated) { _vertices.Clear(); _vertices.AddRange(Flatten()); } return(new Vertices(_vertices)); }
public void Clear() { foreach (Vertex v in Vertices) { Destroy(v.gameObject); } Vertices.Clear(); IterableVertices.Clear(); }
protected static void VerticesToFarseer(Vector2[] vertices, float scale, Vertices transformed) { transformed.Clear(); transformed.Capacity = Math.Min(transformed.Capacity, vertices.Length); for (int i = 0; i < vertices.Length; i++) { transformed.Add(PhysicsUnit.LengthToPhysical * vertices[i] * scale); } }
public void Clear() { foreach (var v in Vertices.Values) { RemoveVertex(v); } Vertices.Clear(); Edges.Clear(); }
private void ClearAll() { Vertices.Clear(); Normals.Clear(); Colors.Clear(); UV.Clear(); Geometries.Clear(); Materials.Clear(); BoundingBox = new BoundingBox(); }
//From Eric Jordan's convex decomposition library /// <summary> /// Merges all parallel edges in the list of vertices /// </summary> /// <param name="vertices">The vertices.</param> /// <param name="tolerance">The tolerance.</param> public static void MergeParallelEdges(Vertices vertices, float tolerance) { if (vertices.Count <= 3) return; //Can't do anything useful here to a triangle bool[] mergeMe = new bool[vertices.Count]; int newNVertices = vertices.Count; //Gather points to process for (int i = 0; i < vertices.Count; ++i) { int lower = (i == 0) ? (vertices.Count - 1) : (i - 1); int middle = i; int upper = (i == vertices.Count - 1) ? (0) : (i + 1); float dx0 = vertices[middle].X - vertices[lower].X; float dy0 = vertices[middle].Y - vertices[lower].Y; float dx1 = vertices[upper].Y - vertices[middle].X; float dy1 = vertices[upper].Y - vertices[middle].Y; float norm0 = (float) Math.Sqrt(dx0*dx0 + dy0*dy0); float norm1 = (float) Math.Sqrt(dx1*dx1 + dy1*dy1); if (!(norm0 > 0.0f && norm1 > 0.0f) && newNVertices > 3) { //Merge identical points mergeMe[i] = true; --newNVertices; } dx0 /= norm0; dy0 /= norm0; dx1 /= norm1; dy1 /= norm1; float cross = dx0*dy1 - dx1*dy0; float dot = dx0*dx1 + dy0*dy1; if (Math.Abs(cross) < tolerance && dot > 0 && newNVertices > 3) { mergeMe[i] = true; --newNVertices; } else mergeMe[i] = false; } if (newNVertices == vertices.Count || newNVertices == 0) return; int currIndex = 0; //Copy the vertices to a new list and clear the old Vertices oldVertices = new Vertices(vertices); vertices.Clear(); for (int i = 0; i < oldVertices.Count; ++i) { if (mergeMe[i] || newNVertices == 0 || currIndex == newNVertices) continue; Debug.Assert(currIndex < newNVertices); vertices.Add(oldVertices[i]); ++currIndex; } }