|
public static CopyNodesAndEdges ( List |
||
| _nodes | List |
|
| _edges | List |
|
| _newNodes | List |
|
| _newEdges | List |
|
| adjacentCheck | bool | |
| cleanUp | bool | |
| return | void | |
public void ProcessMinimalCycles()
{
if (GraphID == -1)
{
GraphID = Guid.NewGuid().GetHashCode();
}
// Use different lists of nodes and edges for processing time, so the serialized lists won't change
m_edges = new List <Edge>();
m_nodes = new List <Node>();
m_primitives = new List <Primitive>();
UtilityTools.Helper.DestroyChildren(transform);
EdgeGraphUtility.CopyNodesAndEdges(nodes, edges, out m_nodes, out m_edges);
EdgeGraphUtility.CheckAdjacentNodes(ref m_nodes, ref m_edges);
MinimalCycle.Extract(ref m_nodes, ref m_edges, ref m_primitives);
// Serialize and process primitives
mainPrimitives = m_primitives;
try
{
ProcessPrimitives();
}
catch (Exception e)
{
Debug.LogWarning("Graph::ProcessMinimalCycles() - Error while processing primitives: " + e.Message);
}
}
/// <summary>
/// Makes copies of edges given by the graph for later modifications
/// New edges will have new IDs and new copies of nodes
/// </summary>
void CopyNodesAndEdges()
{
List <Node> _newNodes = new List <Node>();
List <Edge> _newEdges = new List <Edge>();
EdgeGraphUtility.CopyNodesAndEdges(nodes, edges, out _newNodes, out _newEdges);
nodes = _newNodes;
edges = _newEdges;
}
void GenerateSubEdges()
{
// Save hard copies of this primitive's original nodes and edges
List <Node> nodeCopies = new List <Node>();
List <Edge> edgeCopies = new List <Edge>();
EdgeGraphUtility.CopyNodesAndEdges(nodes, edges, out nodeCopies, out edgeCopies, false, false);
if (subEdgeSegmentLength <= 0f || subEdgeTargets == null || subEdgeTargets.Count <= 0)
{
return;
}
if (subEdgeRootIndex >= nodeCopies.Count)
{
subEdgeRootIndex = nodeCopies.Count - 1;
}
Node rootNode = nodeCopies[subEdgeRootIndex];
//EdgeBuilder builder = null;
if (subEdgeSegmentLength == 0f)
{
subEdgeSegmentLength = .5f;
}
List <Node> _builtSubNodes = new List <Node>();
List <Edge> _builtSubEdges = new List <Edge>();
new EdgeBuilder(rootNode, subEdgeTargets, subEdgeWidth, subEdgeSegmentLength, subEdgeMinAngle, subEdgeMinDistance, subEdgeMaxDistance, (_nodes, _edges) =>
{
if (_nodes == null || _nodes.Count <= 0)
{
Debug.Log("Primitive::GenerateSubEdges() - Builder nodes null / empty.");
return;
}
_builtSubNodes = _nodes;
if (_edges == null || _edges.Count <= 0)
{
Debug.Log("Primitive::GenerateSubEdges() - Builder edges null / empty.");
return;
}
_builtSubEdges = _edges;
CombineSubNodes(rootNode, _builtSubNodes, _builtSubEdges, subEdgeNodeCombineRange);
});
nodeCopies.AddRange(_builtSubNodes);
edgeCopies.AddRange(_builtSubEdges);
ConnectEndPoints(nodeCopies, edgeCopies);
CombineSubNodes(rootNode, nodeCopies, edgeCopies, subEdgeNodeCombineRange, false);
List <Node> _copiedSubNodes = new List <Node>();
List <Edge> _copiedSubEdges = new List <Edge>();
EdgeGraphUtility.CopyNodesAndEdges(nodeCopies, edgeCopies, out _copiedSubNodes, out _copiedSubEdges);
EdgeGraphUtility.CheckAdjacentNodes(ref nodeCopies, ref edgeCopies);
EdgeGraphUtility.CleanUpEdges(ref nodeCopies, ref edgeCopies);
subNodes = nodeCopies;
subEdges = edgeCopies;
}
void ProcessSubPrimitives(Primitive p)
{
if (p.subEdges == null || p.subEdges.Count <= 0)
{
return;
}
// Copy local lists from primitive's sub nodes and edges
List <Node> _nodes = new List <Node>();
List <Edge> _edges = new List <Edge>();
EdgeGraphUtility.CopyNodesAndEdges(p.subNodes, p.subEdges, out _nodes, out _edges);
EdgeGraphUtility.CheckAdjacentNodes(ref _nodes, ref _edges);
//subPrimitives = new List<Primitive>();
List <Primitive> _subPrimitives = new List <Primitive>();
// Extract primitives inside main primitives
try
{
MinimalCycle.Extract(ref _nodes, ref _edges, ref _subPrimitives);
}
catch (Exception e)
{
Debug.LogWarning("Graph::GeneratePrimitiveSubPrimitives() - Error while extracting primitives: " + e.Message);
return;
}
_subPrimitives.ForEach((sp) =>
{
sp.Process();
});
for (int i = _subPrimitives.Count - 1; i >= 0; i--)
{
if (!_subPrimitives[i].EvaluationResult)
{
_subPrimitives.RemoveAt(i);
}
}
_subPrimitives.ForEach((sp) =>
{
sp.parent = p.ID;
GameObject subGraphObj = new GameObject("SubGraph");
subGraphObj.transform.SetParent(transform);
subGraphObj.transform.localPosition = Vector3.zero;
subGraphObj.transform.localScale = Vector3.one;
Graph subGraph = subGraphObj.AddComponent <Graph>();
subGraph.GraphID = Guid.NewGuid().GetHashCode();
subGraphObj.name += subGraph.GraphID;
subGraph.nodes = new List <Node>();
foreach (var node in sp.nodes)
{
subGraph.nodes.Add(node);
}
subGraph.edges = new List <Edge>();
foreach (var edge in sp.edges)
{
edge.Width = 0f;
subGraph.edges.Add(edge);
}
subGraph.ProcessMinimalCycles();
subGraph.mainPrimitives[0].parent = p.ID;
subGraphs.Add(subGraph);
//subPrimitives.Add(subGraph.mainPrimitives[0]);
FacadeBuilder builder = GetComponent <FacadeBuilder>();
if (builder != null)
{
FacadeBuilder subBuilder = subGraph.gameObject.AddComponent <FacadeBuilder>();
subBuilder.inSet = builder.inSet;
subBuilder.facadeStretchPrefab = builder.facadeStretchPrefab;
subBuilder.facadePrefabs = builder.facadePrefabs;
subBuilder.roofMiddleMaterial = builder.roofMiddleMaterial;
subBuilder.roofSideMaterial = builder.roofSideMaterial;
subBuilder.roofHeight = builder.roofHeight;
subBuilder.roofMiddleAddHeight = builder.roofMiddleAddHeight;
subBuilder.roofAccentWidth = builder.roofAccentWidth;
}
FootprintPlacer placer = GetComponent <FootprintPlacer>();
if (placer != null)
{
FootprintPlacer _placer = subGraph.gameObject.AddComponent <FootprintPlacer>();
_placer.footprintPrefabsOnEdge = placer.footprintPrefabsOnEdge;
_placer.footprintPrefabsInside = placer.footprintPrefabsInside;
_placer.UpdateData();
}
});
}
