/// <summary>
/// Builds a new empty directed graph with default vertex and edge
/// provider.
/// </summary>
/// <remarks>
/// </remarks>
public AdjacencyGraph()
{
this.vertexProvider = new QuickGraph.Providers.VertexProvider();
this.edgeProvider = new QuickGraph.Providers.EdgeProvider();
this.allowParallelEdges = true;
this.vertexOutEdges = new VertexEdgesDictionary();
}
/// <summary>
/// Builds a new empty directed graph with default vertex and edge
/// provider.
/// </summary>
/// <param name="allowParallelEdges">true if parallel edges are allowed</param>
public PetriGraph(bool allowParallelEdges)
{
this.vertexProvider = new QuickGraph.Providers.VertexProvider();
this.edgeProvider = new QuickGraph.Providers.EdgeProvider();
this.allowParallelEdges = allowParallelEdges;
this.vertexOutEdges = new VertexEdgesDictionary();
}
/// <summary>
///
/// </summary>
/// <param name="graphType"></param>
/// <param name="vertexProviderType"></param>
/// <param name="edgeProviderType"></param>
/// <param name="directed"></param>
/// <param name="allowParallelEdges"></param>
/// <returns></returns>
protected ISerializableVertexAndEdgeListGraph CreateGraph(
Type graphType,
Type vertexProviderType,
Type edgeProviderType,
bool directed,
bool allowParallelEdges
)
{
// create providers
IVertexProvider vp =
(IVertexProvider)vertexProviderType.GetConstructor(Type.EmptyTypes).Invoke(null);
IEdgeProvider ep =
(IEdgeProvider)edgeProviderType.GetConstructor(Type.EmptyTypes).Invoke(null);
// create graph
Type[] gts = new Type[3];
gts[0] = typeof(IVertexProvider);
gts[1] = typeof(IEdgeProvider);
gts[2] = typeof(bool);
Object[] gps = new Object[3];
gps[0] = vp;
gps[1] = ep;
gps[2] = allowParallelEdges;
return((ISerializableVertexAndEdgeListGraph)graphType.GetConstructor(gts).Invoke(gps));
}
/// <summary>
/// Builds a new empty directed graph with default vertex and edge
/// provider.
/// </summary>
/// <param name="allowParallelEdges">true if parallel edges are allowed</param>
public PetriGraph(bool allowParallelEdges)
{
this.vertexProvider = new QuickGraph.Providers.VertexProvider();
this.edgeProvider = new QuickGraph.Providers.EdgeProvider();
this.allowParallelEdges = allowParallelEdges;
this.vertexOutEdges = new VertexEdgesDictionary();
}
/// <summary>
/// Builds a new empty directed graph with default vertex and edge
/// provider.
/// </summary>
/// <remarks>
/// </remarks>
public AdjacencyGraph()
{
this.vertexProvider = new QuickGraph.Providers.VertexProvider();
this.edgeProvider = new QuickGraph.Providers.EdgeProvider();
this.allowParallelEdges = true;
this.vertexOutEdges = new VertexEdgesDictionary();
}
/// <summary>
/// Builds a new empty graph
/// </summary>
public BidirectionalGraph(
IVertexProvider vertexProvider,
IEdgeProvider edgeProvider,
bool allowParallelEdges
)
: base(vertexProvider,edgeProvider,allowParallelEdges)
{
m_VertexInEdges = new VertexEdgesDictionary();
}
/// <summary>
/// Builds a new empty graph
/// </summary>
public BidirectionalGraph(
IVertexProvider vertexProvider,
IEdgeProvider edgeProvider,
bool allowParallelEdges
)
: base(vertexProvider, edgeProvider, allowParallelEdges)
{
m_VertexInEdges = new VertexEdgesDictionary();
}
public AdjacencyGraph(IVertexProvider vertexProvider, IEdgeProvider edgeProvider, bool allowParallelEdges)
{
if (vertexProvider == null)
{
throw new ArgumentNullException("vertex provider");
}
if (edgeProvider == null)
{
throw new ArgumentNullException("edge provider");
}
this.vertexProvider = vertexProvider;
this.edgeProvider = edgeProvider;
this.allowParallelEdges = allowParallelEdges;
this.vertexOutEdges = new VertexEdgesDictionary();
}
/// <summary>
/// Builds a new empty directed graph with custom providers
/// </summary>
/// <param name="allowParallelEdges">true if the graph allows
/// multiple edges</param>
/// <param name="edgeProvider">custom edge provider</param>
/// <param name="vertexProvider">custom vertex provider</param>
/// <exception cref="ArgumentNullException">
/// vertexProvider or edgeProvider is a null reference
/// </exception>
public PetriGraph(
IVertexProvider vertexProvider,
IEdgeProvider edgeProvider,
bool allowParallelEdges
)
{
if (vertexProvider == null)
{
throw new ArgumentNullException("vertex provider");
}
if (edgeProvider == null)
{
throw new ArgumentNullException("edge provider");
}
this.vertexProvider = vertexProvider;
this.edgeProvider = edgeProvider;
this.allowParallelEdges = allowParallelEdges;
this.vertexOutEdges = new VertexEdgesDictionary();
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
protected void ReadGraphXml(XmlReader reader)
{
if (!reader.Read() || reader.Name != "graph")
{
throw new Exception("could not find graph node");
}
// getting types
MoveToAttribute(reader, "type");
Type graphType = Type.GetType(reader.Value, true);
MoveToAttribute(reader, "vertex-provider-type");
Type vertexProviderType = Type.GetType(reader.Value, true);
MoveToAttribute(reader, "edge-provider-type");
Type edgeProviderType = Type.GetType(reader.Value, true);
MoveToAttribute(reader, "directed");
bool directed = bool.Parse(reader.Value);
MoveToAttribute(reader, "allow-parallel-edges");
bool allowParallelEdges = bool.Parse(reader.Value);
// create providers
IVertexProvider vp = (IVertexProvider)vertexProviderType.GetConstructor(Type.EmptyTypes).Invoke(null);
IEdgeProvider ep = (IEdgeProvider)edgeProviderType.GetConstructor(Type.EmptyTypes).Invoke(null);
// create graph
Type[] gts = new Type[3];
gts[0] = typeof(IVertexProvider);
gts[1] = typeof(IEdgeProvider);
gts[2] = typeof(bool);
Object[] gps = new Object[3];
gps[0] = vp;
gps[1] = ep;
gps[2] = allowParallelEdges;
Graph = (ISerializableVertexAndEdgeListGraph)graphType.GetConstructor(gts).Invoke(gps);
}
public static GameObject Create(
// Vector3 position,
IVertexProvider VertEdge,
Vector3 upDirection,
Vector3 bridgeDirection,
Material material)
{
var go = new GameObject("MakeBridgeGeometry.Create();");
var mf = go.AddComponent <MeshFilter>();
var mesh = mf.mesh;
List <Vector3> newVerts = new List <Vector3>();
List <int> newTris = new List <int>();
List <Vector2> newUVs = new List <Vector2>();
float bridgeDistance = bridgeDirection.magnitude;
// make a strip going down
Vector3 prevVert = Vector3.zero;
Vector2 downUV = new Vector2(0, 1);
Vector2 leftUV = new Vector2(0, 0);
Vector2 rightUV = new Vector2(1, 0);
// compute where we should go
Vector3 location = go.transform.position;
{
var centroid = Vector3.zero;
int vertCount = 0;
foreach (var v in VertEdge.GetVertices())
{
centroid += v;
vertCount++;
}
if (vertCount > 0)
{
centroid /= vertCount;
}
// stick this bridge geometry origin at the centroid of
// the edges plus half the bridge distance
location = centroid + bridgeDirection / 2;;
go.transform.position = location;
}
foreach (var v in VertEdge.GetVertices())
{
var v2 = v + bridgeDirection;
// raycast this part down to match the first collider we hit
var ray = new Ray(origin: v2, direction: -upDirection);
RaycastHit hit;
if (Physics.Raycast(ray: ray, hitInfo: out hit, maxDistance: 100))
{
v2 = hit.point;
}
int n = newVerts.Count;
float vDistance = (v - prevVert).magnitude;
float step = vDistance / bridgeDistance;
newVerts.Add(v);
newVerts.Add(v2);
newUVs.Add(leftUV);
newUVs.Add(rightUV);
leftUV += downUV * step;
rightUV += downUV * step;
if (n > 0)
{
newTris.Add(n - 2);
newTris.Add(n);
newTris.Add(n - 1);
newTris.Add(n);
newTris.Add(n + 1);
newTris.Add(n - 1);
}
prevVert = v;
}
// back out our local position from these points,
// since points are in local space
for (int i = 0; i < newVerts.Count; i++)
{
newVerts[i] -= location;
}
mesh.vertices = newVerts.ToArray();
mesh.triangles = newTris.ToArray();
mesh.uv = newUVs.ToArray();
mesh.RecalculateBounds();
mesh.RecalculateNormals();
mf.mesh = mesh;
var mr = go.AddComponent <MeshRenderer>();
mr.material = material;
return(go);
}
