// 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;
}
}
