/// <summary>
/// LoadContent はゲームごとに 1 回呼び出され、ここですべてのコンテンツを
/// 読み込みます。
/// </summary>
protected override void LoadContent()
{
//モデルの読み込み
model = MMDXCore.Instance.LoadModel("Miku", Content);
//サンプルモデルはカリングを行わない。(他のモデルはカリングを行う)
model.Culling = false;
//カメラとライトモーションの読み込み
camera = MMDXCore.Instance.LoadMotion("Camera", Content);
light = MMDXCore.Instance.LoadMotion("Light", Content);
//ステージプレイヤーにモーションをセット
MMDXCore.Instance.StageAnimationPlayer.AddMotion("Camera", camera);
MMDXCore.Instance.StageAnimationPlayer.AddMotion("Light", light);
//ループ再生
MMDXCore.Instance.StageAnimationPlayer["Camera"].Start(true);
MMDXCore.Instance.StageAnimationPlayer["Light"].Start(true);
//エッジマネージャの作成
edgeManager = new EdgeManager(Window, GraphicsDevice);
//エッジマネージャの登録
MMDXCore.Instance.EdgeManager = edgeManager;
}
void KMeansClustering()
{
print("k-means started..");
// calculate centroid points
int k_means = k_clusters;
int[] k_calculations = new int[k_means];
for (int i = 0; i < k_means; i++)
{
decimal f = Decimal.Divide(i, k_means);
float division = (float)f;
k_calculations[i] = Mathf.RoundToInt(colombs_nodes.Count * (division));
print("k means calculation: " + f + " = " + i + " / " + k_means);
}
print("step 0, k_means = " + k_means);
int k_num = 0;
foreach (int num in k_calculations)
{
//print(k_num +" : "+num);
k_num++;
}
// Assigning centroids
GameObject[] centroids = new GameObject[k_means];
VisualNode[] vs_c = new VisualNode[k_means];
ArrayList[] clusternodes = new ArrayList[k_means];
for (int i = 0; i < k_means; i++)
{
centroids[i] = (GameObject)colombs_nodes[k_calculations[i]];
vs_c[i] = centroids[i].GetComponent <VisualNode>();
vs_c[i].distinct_node = true;
Vector3 localScale = vs_c[i].transform.localScale;
if (transform.localScale.x < 2)
{
//vs_c[i].transform.localScale = new Vector3(localScale.x * 2, localScale.y * 2, localScale.z * 2);
}
clusternodes[i] = new ArrayList();
clusternodes[i].Add(vs_c[i]);
}
print("step 1");
// Assigning nodes to centroids on Euclidean Distance
foreach (GameObject g in colombs_nodes)
{
if (centroids.Contains(g) == false)
{
VisualNode n = g.GetComponent <VisualNode>();
float[] dist_array = new float[k_means];
for (int i = 0; i < dist_array.Length; i++)
{
dist_array[i] = Vector3.Distance(g.transform.localPosition, centroids[i].transform.localPosition);
}
float smallest_dist = dist_array.Min();
int smallest_index = 0;
for (int i = 0; i < dist_array.Length; i++)
{
if (dist_array[i] == smallest_dist)
{
smallest_index = i;
}
}
clusternodes[smallest_index].Add(n);
}
}
print("step 2");
// Create Cluster Objects
GameObject[] clusterObjects = new GameObject[k_means];
for (int i = 0; i < k_means; i++)
{
clusterObjects[i] = new GameObject();
clusterObjects[i].AddComponent <ClusterBehaviour>();
clusterObjects[i].GetComponent <ClusterBehaviour>().setArrayList(clusternodes[i]);
clusterObjects[i].GetComponent <ClusterBehaviour>().setClusterCentre(centroids[i]);
}
print("step 3");
int cluster_index = 0;
// Go through the three centroids and generate the clusters
foreach (GameObject cluster_object in clusterObjects)
{
ClusterBehaviour clu = cluster_object.GetComponent <ClusterBehaviour>();
// return nodes of cluster c
ArrayList cluster_array = clu.returnClusterNodes();
// setup meshfilters for child objects
MeshFilter[] meshFilters = new MeshFilter[clu.returnClusterNodes().Count + 1];
// combine instance mesh array
CombineInstance[] combine = new CombineInstance[meshFilters.Length];
// Color of cluster
Color col = UnityEngine.Random.ColorHSV(0.1f, 0.8f, 0.7f, 1f, 0.5f, 1f);
// go through each child node and add to meshFilter array
// first cluster node
GameObject first_node = clu.gameObject;
meshFilters[0] = centroids[cluster_index].GetComponent <MeshFilter>();
combine[0].mesh = meshFilters[0].sharedMesh;
combine[0].transform = meshFilters[0].transform.localToWorldMatrix;
meshFilters[0].gameObject.SetActive(false);
nodes_already_clustered.Add(first_node.GetComponent <VisualNode>());
// add boxcollider for each node
BoxCollider b = cluster_object.AddComponent <BoxCollider>();
b.size = new Vector3(0.05f, 0.05f, 0.05f);
b.center = clu.transform.position;
b.isTrigger = true;
/*
* ArrayList edge = n.getAllocatedEdges();
* if (edge.Count > 0) {
* GameObject index0 = edge[0] as GameObject;
* foreach (GameObject ga in edge) {
* LineRenderer l = ga.GetComponent<LineRenderer>();
* l.material.SetColor("_TintColor", new Color(col.r, col.g, col.b, 0.01f));
* }
* }
*/
int k = 1;
foreach (VisualNode v in clu.returnClusterNodes())
{
if (nodes_already_clustered.Contains(v) == false)
{
GameObject g = v.gameObject;
meshFilters[k] = g.GetComponent <MeshFilter>();
combine[k].mesh = meshFilters[k].sharedMesh;
combine[k].transform = meshFilters[k].transform.localToWorldMatrix;
meshFilters[k].gameObject.SetActive(false);
//nodes.Add(v);
nodes_already_clustered.Add(v);
// add boxcollider for each node
BoxCollider b1 = cluster_object.AddComponent <BoxCollider>();
b1.size = new Vector3(0.05f, 0.05f, 0.05f);
b1.center = g.transform.position;
b1.isTrigger = true;
ArrayList edge1 = v.getAllocatedEdges();
v.transform.parent = cluster_object.transform;
vs_c[cluster_index].addClusterNode(v);
if (edge1.Count > 0)
{
GameObject index0 = edge1[0] as GameObject;
foreach (GameObject ga in edge1)
{
//LineRenderer l = ga.GetComponent<LineRenderer>();
//l.material.SetColor("_TintColor", new Color(col.r, col.g, col.b, 0.01f));
}
}
}
else
{
}
k++;
}
// set the parent of the cluster to visualization object
cluster_object.transform.parent = this.transform;
// set the name of the cluster
//cluster_object.transform.name = first_node.transform.name + " cluster";
// add meshfilter to new cluster
cluster_object.AddComponent <MeshFilter>();
cluster_object.AddComponent <MeshRenderer>();
cluster_object.GetComponent <MeshFilter>().mesh = new Mesh();
// combine all the meshes in the mesh array "combine"
cluster_object.GetComponent <MeshFilter>().mesh.CombineMeshes(combine);
cluster_object.GetComponent <MeshRenderer>().material = nodeMat;
// assign random color to cluster
cluster_object.GetComponent <MeshRenderer>().material.color = col;
clusters.Add(clu);
cluster_index++;
}
EdgeManager edgeManager = Camera.main.GetComponent <EdgeManager> ();
ArrayList glEdges = edgeManager.getEdges();
print(glEdges.Count + "glEdge count");
for (int i = 0; i < glEdges.Count; i++)
{
Edge e = (Edge)glEdges[i];
e.setColor(e.getTransformRef().parent.GetComponent <MeshRenderer>().material.color);
}
print("step 4 DONE");
clusterAllNodes = true;
graph_layout_recognized = false;
}
//Optimisation Test
void CombineMeshes()
{
// go through each clusterNode parent
foreach (VisualNode n in clusterNodes)
{
// arraylist to be added to cluster late
ArrayList nodes = new ArrayList();
// setup meshfilters for child objects
MeshFilter[] meshFilters = new MeshFilter[n.getClusterNodes().Count + 1];
// combine instance mesh array
CombineInstance[] combine = new CombineInstance[meshFilters.Length];
//stop center from being combined
nodes_already_clustered.Add(n);
// Create a new cluster gameobject
GameObject newCluster = new GameObject();
// Color of cluster
Color col = UnityEngine.Random.ColorHSV(0.1f, 0.8f, 0.7f, 1f, 0.5f, 1f);
// go through each child node and add to meshFilter array
// first cluster node
GameObject c1 = n.gameObject;
meshFilters[0] = c1.GetComponent <MeshFilter>();
combine[0].mesh = meshFilters[0].sharedMesh;
combine[0].transform = meshFilters[0].transform.localToWorldMatrix;
meshFilters[0].gameObject.SetActive(false);
nodes.Add(n);
nodes_already_clustered.Add(n);
// add boxcollider for each node
//BoxCollider b = newCluster.AddComponent<BoxCollider>();
//b.size = new Vector3(0.05f, 0.05f, 0.05f);
//b.center = c1.transform.position;
//b.isTrigger = true;
ArrayList edge = n.getAllocatedEdges();
if (edge.Count > 0)
{
GameObject index0 = edge[0] as GameObject;
foreach (GameObject ga in edge)
{
LineRenderer l = ga.GetComponent <LineRenderer>();
l.material.SetColor("_TintColor", new Color(col.r, col.g, col.b, 0.01f));
}
}
int k = 1;
foreach (VisualNode v in n.getClusterNodes())
{
if (nodes_already_clustered.Contains(v) == false)
{
GameObject g = v.gameObject;
meshFilters[k] = g.GetComponent <MeshFilter>();
combine[k].mesh = meshFilters[k].sharedMesh;
combine[k].transform = meshFilters[k].transform.localToWorldMatrix;
meshFilters[k].gameObject.SetActive(false);
nodes.Add(v);
nodes_already_clustered.Add(v);
// add boxcollider for each node
//BoxCollider b1 = newCluster.AddComponent<BoxCollider>();
//b1.size = new Vector3(0.05f, 0.05f, 0.05f);
//b1.center = g.transform.position;
//b1.isTrigger = true;
v.transform.parent = n.transform;
ArrayList edge1 = v.getAllocatedEdges();
if (edge1.Count > 0)
{
GameObject index0 = edge1[0] as GameObject;
foreach (GameObject ga in edge1)
{
LineRenderer l = ga.GetComponent <LineRenderer>();
l.material.SetColor("_TintColor", new Color(col.r, col.g, col.b, 0.01f));
}
}
}
else
{
}
k++;
}
// set the parent of the cluster to visualization object
newCluster.transform.parent = this.transform;
// set the name of the cluster
newCluster.transform.name = n.transform.name + " cluster";
// add meshfilter to new cluster
newCluster.AddComponent <MeshFilter>();
newCluster.AddComponent <MeshRenderer>();
newCluster.GetComponent <MeshFilter>().mesh = new Mesh();
// combine all the meshes in the mesh array "combine"
newCluster.GetComponent <MeshFilter>().mesh.CombineMeshes(combine);
newCluster.GetComponent <MeshRenderer>().material = nodeMat;
// assign random color to cluster
newCluster.GetComponent <MeshRenderer>().material.color = col;
// add clustercode
newCluster.AddComponent <ClusterBehaviour>();
ClusterBehaviour c = newCluster.GetComponent <ClusterBehaviour>();
n.transform.parent = c.transform;
c.setArrayList(nodes);
c.setClusterCentre(n.gameObject);
// lastly, add collider (trying box colliders)
//newCluster.AddComponent<MeshCollider>();
}
EdgeManager edgeManager = Camera.main.GetComponent <EdgeManager> ();
ArrayList glEdges = edgeManager.getEdges();
// print (glEdges.Count + "glEdge count");
for (int i = 0; i < glEdges.Count; i++)
{
Edge e = (Edge)glEdges[i];
e.setColor(e.getTransformRef().parent.parent.GetComponent <MeshRenderer>().material.color);
}
clusterAllNodes = true;
graph_layout_recognized = false;
Camera.main.cullingMask = cullingmask;
}
// Start is called before the first frame update
public void Awake()
{
Origin = GameObject.Find("Origin");
Edges = Origin.GetComponent <EdgeManager>();
}
public static void MaxFlow(Graph graph, Node start, Node finish)
{
graph.ReGraph();
EdgeManager edgeManager = GameObject.Find("Managers").GetComponent <EdgeManager>();
List <Edge> temporaryEdges = new List <Edge>();
float sumFlow = 0;
// Форда-Фалкерсона
// 1 обнуляємо усі потоки
foreach (Dictionary <Node, Edge> node in graph.nodeList.Values)
{
foreach (Edge edge in node.Values)
{
edge.flow = 0;
edge.FlowColor();
}
}
Graph resudalGraph = ResudalGraph(graph); // проверь
// 2
LinkedList <Node> way = AStar(resudalGraph, start, finish, false);
int stop = 0;
while (way != null)
{
stop += 1;
if (stop >= 100)
{
Debug.Log("Стоп кран");
break;
}
// через знайдений коротший шлях пускаємо потік
// знайдемо найменшу
float cMin = Mathf.Infinity;
for (LinkedListNode <Node> node = way.First; node.Next != null; node = node.Next)
{
float c = resudalGraph.nodeList[node.Value][node.Next.Value].ResidualFlow;
cMin = Mathf.Min(cMin, c);
}
// збільшуємо поток на шляху
for (LinkedListNode <Node> node = way.First; node.Next != null; node = node.Next)
{
// resudalGraph.nodeList[node.Value][node.Next.Value].flow += cMin;
// TODO добавить обратное ребро!
// graph.GetEdge(node.Value, node.Next.Value).flow += cMin;
// graph.GetEdge(node.Next.Value, node.Value).flow -= cMin;
GetEdge(node.Value, node.Next.Value).flow += cMin;
GetEdge(node.Next.Value, node.Value).flow -= cMin;
}
resudalGraph = ResudalGraph(resudalGraph);
way = AStar(resudalGraph, start, finish, false);
}
// перенос инфы из остаточного графа в основной
/*
* foreach (KeyValuePair<Node, Dictionary<Node, Edge>> node in resudalGraph.nodeList)
* {
* foreach (KeyValuePair<Node, Edge> subnode in node.Value)
* {
* Edge resudalEdge = resudalGraph.nodeList[node.Key][subnode.Key];
* if (resudalEdge.capacity != 0)
* {
* graph.nodeList[node.Key][subnode.Key].flow = resudalEdge.flow;
* }
* }
* }
*/
foreach (Edge e in temporaryEdges)
{
GameObject.Destroy(e.gameObject);
}
temporaryEdges.Clear();
// обновление интерфейса для все ребер
foreach (KeyValuePair <Node, Dictionary <Node, Edge> > node in graph.nodeList)
{
foreach (Edge edge in node.Value.Values)
{
edge.SetFlowText();
edge.FlowColor();
}
}
// оказалось не костыль, а по определению
foreach (Edge fin in graph.nodeList[start].Values)
{
sumFlow += fin.flow;
}
Debug.Log($"Максимальний потік = {sumFlow}");
// повертає ребро між вузлами, якзо такого нема - створює і повертає
Edge GetEdge(Node nodeA, Node nodeB)
{
Edge edge;
if (resudalGraph.nodeList[nodeA].ContainsKey(nodeB))
{
edge = resudalGraph.nodeList[nodeA][nodeB];
}
else
{
edge = edgeManager.CreateEdge(nodeA, nodeB, resudalGraph, false);
edge.capacity = 0;
temporaryEdges.Add(edge);
}
return(edge);
}
Graph ResudalGraph(Graph initialGraph)
{
// по идее он не создает новые узлы а ссылается на оригинальный граф
// так что и привязки к геймобджектам не надо
Graph resGraph = ScriptableObject.CreateInstance("Graph") as Graph;
foreach (KeyValuePair <Node, Dictionary <Node, Edge> > node in initialGraph.nodeList)
{
foreach (KeyValuePair <Node, Edge> subNode in node.Value)
{
if (subNode.Value.ResidualFlow > 0)
{
resGraph.AddNode(node.Key);
resGraph.AddNode(subNode.Key);
resGraph.AddEdge(node.Key, subNode.Key, subNode.Value);
}
/*
* оно ведь и не добавтися
* else if(subNode.Value.ResidualFlow == 0)
* {
* resGraph.RemoveEdge(node.Key, subNode.Key); // ?????????????
* }
*/
}
}
if (resGraph.nodeList.Count > 0)
{
return(resGraph);
}
else
{
return(null);
}
}
}
Vector3 Centroid(EdgeManager em)
{
return((em.v2.transform.position + em.v1.transform.position) / 2);
}
/// <summary>
/// LoadContent はゲームごとに 1 回呼び出され、ここですべてのコンテンツを
/// 読み込みます。
/// </summary>
protected override void LoadContent()
{
//モデルをパイプラインより読み込み
model = MMDXCore.Instance.LoadModel("Miku-metal", Content);
//サンプルモデルはカリングを行わない。(他のモデルはカリングを行う)
model.Culling = false;
//モーションをパイプラインより読み込み
motion = MMDXCore.Instance.LoadMotion("TrueMyHeart", Content);
//モデルにモーションをセット
model.AnimationPlayer.AddMotion("TrueMyHeart", motion, MMDMotionTrackOptions.UpdateWhenStopped);
//エッジマネージャの作成
edgeManager = new EdgeManager(Window, GraphicsDevice);
//エッジマネージャの登録
MMDXCore.Instance.EdgeManager = edgeManager;
//物理エンジンデバッグの作成
debugDraw = new PhysicsDebugDraw(GraphicsDevice);
//MMDXにセット
MMDXCore.Instance.Physics.DebugDrawer = debugDraw;
//MMDXのProfileイベントとtimeRulerとを接続
MMDXProfiler.MMDBeginMark += (bar, name, color) => timerRuler.BeginMark(bar, name, color);
MMDXProfiler.MMDEndMark += (bar, name) => timerRuler.EndMark(bar, name);
}
public override void OnRegisterEvent()
{
clog("Game session saved ...");
EdgeManager.JoinOrCreateRoom(playerName: "", playerAvatar: 0, maxPlayersPerRoom: 2);
}
public override void OnPlayerLeft(RoomMemberLeft playerLeft)
{
clog(EdgeManager.GetPlayer(playerLeft.idOfPlayerLeft).playerName + " left");
theBall.transform.position = Vector3.zero;
}
