// Start is called before the first frame update
void Start()
{
float t_original = Time.realtimeSinceStartup;
GameObject MPC_Spawner = GameObject.Find("MPC_spawner");
Scatterers_Spawning2 MPC_Script = MPC_Spawner.GetComponent <Scatterers_Spawning2>();
List <Vector3> MPC1 = MPC_Script.MPC1_possiblepositionList;
List <Vector3> MPC2 = MPC_Script.MPC2_possiblepositionList;
List <Vector3> MPC3 = MPC_Script.MPC3_possiblepositionList;
List <Vector3> DMC = MPC_Script.DMC_possiblepositionList;
// Declaring buildings and observation points
Buildings = GameObject.FindGameObjectsWithTag("Reflecting_Obstacles");
// The number of observation points should not be too big, a few is enough
Observation_Points = GameObject.FindGameObjectsWithTag("Observation_Points");
// Define the main road direction
Vector3 main_axis = (Observation_Points[0].transform.position - Observation_Points[1].transform.position).normalized;
Vector3 perp_axis = new Vector3(main_axis.z, 0, -main_axis.x);
// subset of the seen Buldings
List <GameObject> Building_list = new List <GameObject>();
// Going through all observation points
for (int k = 0; k < Observation_Points.Length; k++)
{
// analyzing which buidings are seen
for (int b = 0; b < Buildings.Length; b++)
{
Vector3[] vrtx = Buildings[b].GetComponent <MeshFilter>().mesh.vertices;
Vector3[] nrml = Buildings[b].GetComponent <MeshFilter>().mesh.normals;
int seen_vrtx_count = 0;
for (int v = 0; v < vrtx.Length; v++)
{
if (vrtx[v].y == 0)
{
if (!Physics.Linecast(Observation_Points[k].transform.position, vrtx[v] + 1.1f * nrml[v]))
{
seen_vrtx_count += 1;
}
}
}
if (seen_vrtx_count != 0)
{
if (!Building_list.Contains(Buildings[b]))
{
Building_list.Add(Buildings[b]);
}
}
}
}
// deactivating nonseen buildings
for (int b = 0; b < Buildings.Length; b++)
{
if (!Building_list.Contains(Buildings[b]))
{
Buildings[b].SetActive(false);
}
}
Debug.Log("The number of seen Buildings = " + Building_list.Count);
List <Vector3> GlobalMPC1 = new List <Vector3>();
List <Vector3> GlobalMPC2 = new List <Vector3>();
List <Vector3> GlobalMPC3 = new List <Vector3>();
List <Vector3> GlobalDMC = new List <Vector3>();
// analyzing each seen building separately
for (int k = 0; k < Building_list.Count; k++)
{
// writing MPCs into a txt file
//string writePath;
List <string> Obj_List = new List <string>();
Vector3[] vrtx = Building_list[k].GetComponent <MeshFilter>().mesh.vertices;
Vector3[] nrml = Building_list[k].GetComponent <MeshFilter>().mesh.normals;
List <Vector3> floor_vrtx = new List <Vector3>();
List <Vector3> floor_nrml = new List <Vector3>();
var pairs = new List <V6>();
List <Vector3> possible_vrtx = new List <Vector3>();
List <Vector3> possible_nrml = new List <Vector3>();
for (int l = 0; l < vrtx.Length; l++)
{
if (vrtx[l].y == 0 && Mathf.Abs(nrml[l].y) < 0.9)
{
floor_vrtx.Add(vrtx[l]);
floor_nrml.Add(nrml[l]);
// adding coordinates and normals of the vertices into a single object V6 (like a N x 6 matrix)
V6 valid_pair = new V6(vrtx[l], nrml[l]);
pairs.Add(valid_pair);
}
}
// finding the edges of each building
List <Vector3> SortedByX = floor_vrtx.OrderBy(vertex => vertex.x).ToList();
List <Vector3> SortedByZ = floor_vrtx.OrderBy(vertex => vertex.z).ToList();
float x_l = SortedByX[0].x - WW2; // x left
float x_r = SortedByX[SortedByX.Count - 1].x + WW2; // x right
float z_d = SortedByZ[0].z - WW2; // z down
float z_u = SortedByZ[SortedByX.Count - 1].z + WW2; // z up
// searching which scatterers are located near the building
NearbyElements(x_l, x_r, z_d, z_u, MPC1, out List <Vector3> NearbyMPC1);
NearbyElements(x_l, x_r, z_d, z_u, MPC2, out List <Vector3> NearbyMPC2);
NearbyElements(x_l, x_r, z_d, z_u, MPC3, out List <Vector3> NearbyMPC3);
NearbyElements(x_l, x_r, z_d, z_u, DMC, out List <Vector3> NearbyDMC);
//////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Defining areas around building where scatterers can be located
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// defining necessary elements for the polygon that connects the last and the first vertices
Vector3 n1_0 = floor_nrml[floor_vrtx.Count - 1];
Vector3 p1_0 = floor_vrtx[floor_vrtx.Count - 1];
Vector3 s1_0 = floor_vrtx[floor_vrtx.Count - 1] + WW1 * floor_nrml[floor_vrtx.Count - 1];
Vector3 dmc_s1_0 = floor_vrtx[floor_vrtx.Count - 1] + WW2 * floor_nrml[floor_vrtx.Count - 1];
Vector3 n2_0 = floor_nrml[0];
Vector3 p2_0 = floor_vrtx[0];
Vector3 s2_0 = floor_vrtx[0] + WW1 * floor_nrml[0];
Vector3 dmc_s2_0 = floor_vrtx[0] + WW2 * floor_nrml[0];
Area34 area = new Area34(p1_0, s1_0, p2_0, s2_0);
//DrawArea(area);
PickMPC(n1_0, p1_0, s1_0, n2_0, p2_0, s2_0, NearbyMPC1, out List <V6> MPC1_V6);
PickMPC(n1_0, p1_0, s1_0, n2_0, p2_0, s2_0, NearbyMPC2, out List <V6> MPC2_V6);
PickMPC(n1_0, p1_0, s1_0, n2_0, p2_0, s2_0, NearbyMPC3, out List <V6> MPC3_V6);
PickMPC(n1_0, p1_0, dmc_s1_0, n2_0, p2_0, dmc_s2_0, NearbyMPC3, out List <V6> DMC_V6);
//int MPC1_num = 0;
for (int ii = 0; ii < MPC1_V6.Count; ii++)
{
if (!GlobalMPC1.Contains(MPC1_V6[ii].Coordinates))
{
SeenV6_MPC1.Add(MPC1_V6[ii]);
V7 tempV7_MPC1 = new V7(MPC1_V6[ii], MPC1_num);
SeenV7_MPC1.Add(tempV7_MPC1);
GlobalMPC1.Add(MPC1_V6[ii].Coordinates);
//Entity newMPC1Entity = entityManager.Instantiate(MPC1_entity);
//entityManager.SetComponentData(newMPC1Entity, new Position);
//EntityManager.SetComponentData(newMPC1Entity, new Translation { Value = MPC1_V6[ii].Coordinates }) ;
//MPC1_Prefab.transform.position = MPC1_V6[ii].Coordinates;
if (MPC_visualizer_ECS == true)
{
GameObject MPC1_clone = Instantiate(MPC1_Prefab, MPC1_V6[ii].Coordinates, Quaternion.identity);
MPC1_clone.name = "mpc1 #" + MPC1_num;
}
MPC1_num += 1;
}
}
//int MPC2_num = 0;
for (int ii = 0; ii < MPC2_V6.Count; ii++)
{
if (!GlobalMPC2.Contains(MPC2_V6[ii].Coordinates))
{
SeenV6_MPC2.Add(MPC2_V6[ii]);
V7 tempV7_MPC2 = new V7(MPC2_V6[ii], MPC2_num);
SeenV7_MPC2.Add(tempV7_MPC2);
GlobalMPC2.Add(MPC2_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject MPC2_clone = Instantiate(MPC2_Prefab, MPC2_V6[ii].Coordinates, Quaternion.identity);
MPC2_clone.name = "mpc2 #" + MPC2_num;
}
MPC2_num += 1;
}
}
//int MPC3_num = 0;
for (int ii = 0; ii < MPC3_V6.Count; ii++)
{
if (!GlobalMPC3.Contains(MPC3_V6[ii].Coordinates))
{
SeenV6_MPC3.Add(MPC3_V6[ii]);
V7 tempV7_MPC3 = new V7(MPC3_V6[ii], MPC3_num);
SeenV7_MPC3.Add(tempV7_MPC3);
GlobalMPC3.Add(MPC3_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject MPC3_clone = Instantiate(MPC3_Prefab, MPC3_V6[ii].Coordinates, Quaternion.identity);
MPC3_clone.name = "mpc3 #" + MPC3_num;
}
MPC3_num += 1;
}
}
//int DMC_num = 0;
for (int ii = 0; ii < DMC_V6.Count; ii++)
{
if (!GlobalDMC.Contains(DMC_V6[ii].Coordinates))
{
SeenV6_DMC.Add(DMC_V6[ii]);
V7 tempV7_DMC = new V7(DMC_V6[ii], DMC_num);
SeenV7_DMC.Add(tempV7_DMC);
GlobalDMC.Add(DMC_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject DMC_clone = Instantiate(DMC_Prefab, DMC_V6[ii].Coordinates, Quaternion.identity);
DMC_clone.name = "mpc3 #" + DMC_num;
}
DMC_num += 1;
}
}
// draw areas for all vertices
Vector3 point1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 point2 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 shift1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 shift2 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 dmc_shift1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 dmc_shift2 = new Vector3(0.0f, 0.0f, 0.0f);
for (int l = 0; l < floor_vrtx.Count - 1; l++)
{
point1 = floor_vrtx[l];
point2 = floor_vrtx[l + 1];
shift1 = floor_vrtx[l] + WW1 * floor_nrml[l];
shift2 = floor_vrtx[l + 1] + WW1 * floor_nrml[l + 1];
dmc_shift1 = floor_vrtx[l] + WW2 * floor_nrml[l];
dmc_shift2 = floor_vrtx[l + 1] + WW2 * floor_nrml[l + 1];
Area34 area_forloop = new Area34(point1, dmc_shift1, point2, dmc_shift2);
//DrawArea(area_forloop);
PickMPC(floor_nrml[l], point1, shift1, floor_nrml[l + 1], point2, shift2, NearbyMPC1, out List <V6> for_MPC1_V6);
PickMPC(floor_nrml[l], point1, shift1, floor_nrml[l + 1], point2, shift2, NearbyMPC2, out List <V6> for_MPC2_V6);
PickMPC(floor_nrml[l], point1, shift1, floor_nrml[l + 1], point2, shift2, NearbyMPC3, out List <V6> for_MPC3_V6);
// picking DMCs
PickMPC(floor_nrml[l], point1, dmc_shift1, floor_nrml[l + 1], point2, dmc_shift2, NearbyDMC, out List <V6> for_DMC_V6);
// MPC1
for (int ii = 0; ii < for_MPC1_V6.Count; ii++)
{
if (!GlobalMPC1.Contains(for_MPC1_V6[ii].Coordinates))
{
SeenV6_MPC1.Add(for_MPC1_V6[ii]);
V7 tempV7_MPC1 = new V7(for_MPC1_V6[ii], MPC1_num);
SeenV7_MPC1.Add(tempV7_MPC1);
GlobalMPC1.Add(for_MPC1_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject clone = Instantiate(MPC1_Prefab, for_MPC1_V6[ii].Coordinates, Quaternion.identity);
clone.name = "mpc1 #" + MPC1_num;
}
MPC1_num += 1;
}
}
// MPC2
for (int ii = 0; ii < for_MPC2_V6.Count; ii++)
{
if (!GlobalMPC2.Contains(for_MPC2_V6[ii].Coordinates))
{
SeenV6_MPC2.Add(for_MPC2_V6[ii]);
V7 tempV7_MPC2 = new V7(for_MPC2_V6[ii], MPC2_num);
SeenV7_MPC2.Add(tempV7_MPC2);
GlobalMPC2.Add(for_MPC2_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject MPC2_clone = Instantiate(MPC2_Prefab, for_MPC2_V6[ii].Coordinates, Quaternion.identity);
MPC2_clone.name = "mpc2 #" + MPC2_num;
}
MPC2_num += 1;
}
}
// MPC3
for (int ii = 0; ii < for_MPC3_V6.Count; ii++)
{
if (!GlobalMPC3.Contains(for_MPC3_V6[ii].Coordinates))
{
SeenV6_MPC3.Add(for_MPC3_V6[ii]);
V7 tempV7_MPC3 = new V7(for_MPC3_V6[ii], MPC3_num);
SeenV7_MPC3.Add(tempV7_MPC3);
GlobalMPC3.Add(for_MPC3_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject MPC3_clone = Instantiate(MPC3_Prefab, for_MPC3_V6[ii].Coordinates, Quaternion.identity);
MPC3_clone.name = "mpc3 #" + MPC3_num;
}
MPC3_num += 1;
}
}
// DMCs
for (int ii = 0; ii < for_DMC_V6.Count; ii++)
{
if (!GlobalDMC.Contains(for_DMC_V6[ii].Coordinates))
{
SeenV6_DMC.Add(for_DMC_V6[ii]);
V7 tempV7_DMC = new V7(for_DMC_V6[ii], DMC_num);
SeenV7_DMC.Add(tempV7_DMC);
GlobalDMC.Add(for_DMC_V6[ii].Coordinates);
if (MPC_visualizer_ECS == true)
{
GameObject DMC_clone = Instantiate(DMC_Prefab, for_DMC_V6[ii].Coordinates, Quaternion.identity);
DMC_clone.name = "dmc #" + DMC_num;
}
DMC_num += 1;
}
}
}
//Area2D(vv1, vv2, out float S11);
}
Debug.Log("Number of seen MPC1 = " + SeenV7_MPC1.Count + "; check number " + MPC1_num);
Debug.Log("Number of seen MPC2 = " + SeenV7_MPC2.Count + "; check number " + MPC2_num);
Debug.Log("Number of seen MPC3 = " + SeenV7_MPC3.Count + "; check number " + MPC3_num);
Debug.Log("Number of seen DMCs = " + SeenV7_DMC.Count + "; check number " + DMC_num);
Debug.Log("Check Time t_original: " + ((Time.realtimeSinceStartup - t_original) * 1000f) + " ms");
}
// Start is called before the first frame update
void Start()
{
GameObject MPC_Spawner = GameObject.Find("MPC_spawner");
Scatterers_Spawning2 MPC_Script = MPC_Spawner.GetComponent <Scatterers_Spawning2>();
List <Vector3> MPC1 = MPC_Script.MPC1_possiblepositionList;
List <Vector3> MPC2 = MPC_Script.MPC2_possiblepositionList;
List <Vector3> MPC3 = MPC_Script.MPC3_possiblepositionList;
/*
* Debug.Log("Number of MPC1 is " + MPC1.Count);
* for (int i = 0; i < MPC1.Count; i++)
* {
* GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
*
* cleared_sphere.transform.position = MPC1[i];
* Destroy(cleared_sphere.GetComponent<SphereCollider>()); // remove collider
* var sphereRenderer = cleared_sphere.GetComponent<Renderer>();
* sphereRenderer.material = MPC2_mat;
* cleared_sphere.transform.localScale = new Vector3(0.3f, 0.3f, 0.3f);
* }
*/
// Declaring buildings and observation points
Buildings = GameObject.FindGameObjectsWithTag("Reflecting_Obstacles");
// The number of observation points should not be too big, a few is enough
Observation_Points = GameObject.FindGameObjectsWithTag("Observation_Points");
// Define the main road direction
Vector3 main_axis = (Observation_Points[0].transform.position - Observation_Points[1].transform.position).normalized;
Vector3 perp_axis = new Vector3(main_axis.z, 0, -main_axis.x);
// subset of the seen Buldings
List <GameObject> Building_list = new List <GameObject>();
// Going through all observation points
for (int k = 0; k < Observation_Points.Length; k++)
{
// analyzing which buidings are seen
for (int b = 0; b < Buildings.Length; b++)
{
Vector3[] vrtx = Buildings[b].GetComponent <MeshFilter>().mesh.vertices;
Vector3[] nrml = Buildings[b].GetComponent <MeshFilter>().mesh.normals;
int seen_vrtx_count = 0;
for (int v = 0; v < vrtx.Length; v++)
{
if (vrtx[v].y == 0)
{
if (!Physics.Linecast(Observation_Points[k].transform.position, vrtx[v] + 1.1f * nrml[v]))
{
seen_vrtx_count += 1;
}
}
}
if (seen_vrtx_count != 0)
{
if (!Building_list.Contains(Buildings[b]))
{
Building_list.Add(Buildings[b]);
}
}
}
}
// deactivating nonseen buildings
for (int b = 0; b < Buildings.Length; b++)
{
if (!Building_list.Contains(Buildings[b]))
{
Buildings[b].SetActive(false);
}
}
Debug.Log("The number of seen Buildings = " + Building_list.Count);
List <Vector3> GlobalMPC1 = new List <Vector3>();
List <Vector3> GlobalMPC2 = new List <Vector3>();
List <Vector3> GlobalMPC3 = new List <Vector3>();
// analyzing each seen building separately
for (int k = 0; k < Building_list.Count; k++)
{
// writing MPCs into a txt file
//string writePath;
List <string> Obj_List = new List <string>();
Vector3[] vrtx = Building_list[k].GetComponent <MeshFilter>().mesh.vertices;
Vector3[] nrml = Building_list[k].GetComponent <MeshFilter>().mesh.normals;
List <Vector3> floor_vrtx = new List <Vector3>();
List <Vector3> floor_nrml = new List <Vector3>();
var pairs = new List <V6>();
List <Vector3> possible_vrtx = new List <Vector3>();
List <Vector3> possible_nrml = new List <Vector3>();
for (int l = 0; l < vrtx.Length; l++)
{
if (vrtx[l].y == 0 && Mathf.Abs(nrml[l].y) < 0.9)
{
floor_vrtx.Add(vrtx[l]);
floor_nrml.Add(nrml[l]);
// adding coordinates and normals of the vertices into a single object V6 (like a N x 6 matrix)
V6 valid_pair = new V6(vrtx[l], nrml[l]);
pairs.Add(valid_pair);
}
}
// finding the edges of each building
List <Vector3> SortedByX = floor_vrtx.OrderBy(vertex => vertex.x).ToList();
List <Vector3> SortedByZ = floor_vrtx.OrderBy(vertex => vertex.z).ToList();
float x_l = SortedByX[0].x - WW1; // x left
float x_r = SortedByX[SortedByX.Count - 1].x + WW1; // x right
float z_d = SortedByZ[0].z - WW1; // z down
float z_u = SortedByZ[SortedByX.Count - 1].z + WW1; // z up
// searching which scatterers are located near the building
NearbyElements(x_l, x_r, z_d, z_u, MPC1, out List <Vector3> NeabyMPC1);
NearbyElements(x_l, x_r, z_d, z_u, MPC2, out List <Vector3> NeabyMPC2);
NearbyElements(x_l, x_r, z_d, z_u, MPC3, out List <Vector3> NeabyMPC3);
//////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Defining areas around building where scatterers can be located
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// defining necessary elements for the polygon that connects the last and the first vertices
Vector3 n1_0 = floor_nrml[floor_vrtx.Count - 1];
Vector3 p1_0 = floor_vrtx[floor_vrtx.Count - 1];
Vector3 s1_0 = floor_vrtx[floor_vrtx.Count - 1] + WW1 * floor_nrml[floor_vrtx.Count - 1];
Vector3 n2_0 = floor_nrml[0];
Vector3 p2_0 = floor_vrtx[0];
Vector3 s2_0 = floor_vrtx[0] + WW1 * floor_nrml[0];
Area34 area = new Area34(p1_0, s1_0, p2_0, s2_0);
//DrawArea(area);
PickMPC(n1_0, p1_0, s1_0, n2_0, p2_0, s2_0, NeabyMPC1, out List <V6> MPC1_V6);
PickMPC(n1_0, p1_0, s1_0, n2_0, p2_0, s2_0, NeabyMPC2, out List <V6> MPC2_V6);
PickMPC(n1_0, p1_0, s1_0, n2_0, p2_0, s2_0, NeabyMPC3, out List <V6> MPC3_V6);
//int MPC1_num = 0;
for (int ii = 0; ii < MPC1_V6.Count; ii++)
{
if (!GlobalMPC1.Contains(MPC1_V6[ii].Coordinates))
{
SeenV6_MPC1.Add(MPC1_V6[ii]);
V7 tempV7_MPC1 = new V7(MPC1_V6[ii], MPC1_num);
SeenV7_MPC1.Add(tempV7_MPC1);
GlobalMPC1.Add(MPC1_V6[ii].Coordinates);
GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cleared_sphere.transform.position = MPC1_V6[ii].Coordinates;
Destroy(cleared_sphere.GetComponent <SphereCollider>()); // remove collider
// cleared_sphere.name = "Building #" + k + "; mpc1 #" + MPC1_num;
cleared_sphere.name = "mpc1 #" + MPC1_num;
var sphereRenderer = cleared_sphere.GetComponent <Renderer>();
sphereRenderer.material = MPC1_mat;
cleared_sphere.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
MPC1_num += 1;
}
}
//int MPC2_num = 0;
for (int ii = 0; ii < MPC2_V6.Count; ii++)
{
if (!GlobalMPC2.Contains(MPC2_V6[ii].Coordinates))
{
SeenV6_MPC2.Add(MPC2_V6[ii]);
V7 tempV7_MPC2 = new V7(MPC2_V6[ii], MPC2_num);
SeenV7_MPC2.Add(tempV7_MPC2);
GlobalMPC2.Add(MPC2_V6[ii].Coordinates);
GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cleared_sphere.transform.position = MPC2_V6[ii].Coordinates;
Destroy(cleared_sphere.GetComponent <SphereCollider>()); // remove collider
cleared_sphere.name = "mpc2 #" + MPC2_num;
var sphereRenderer = cleared_sphere.GetComponent <Renderer>();
sphereRenderer.material = MPC2_mat;
cleared_sphere.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
MPC2_num += 1;
}
}
//int MPC3_num = 0;
for (int ii = 0; ii < MPC3_V6.Count; ii++)
{
if (!GlobalMPC3.Contains(MPC3_V6[ii].Coordinates))
{
SeenV6_MPC3.Add(MPC3_V6[ii]);
V7 tempV7_MPC3 = new V7(MPC3_V6[ii], MPC3_num);
SeenV7_MPC3.Add(tempV7_MPC3);
GlobalMPC3.Add(MPC3_V6[ii].Coordinates);
GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cleared_sphere.transform.position = MPC3_V6[ii].Coordinates;
Destroy(cleared_sphere.GetComponent <SphereCollider>()); // remove collider
cleared_sphere.name = "mpc3 #" + MPC3_num;
var sphereRenderer = cleared_sphere.GetComponent <Renderer>();
sphereRenderer.material = MPC3_mat;
cleared_sphere.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
MPC3_num += 1;
}
}
// draw areas for all vertices
Vector3 point1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 point2 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 shift1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 shift2 = new Vector3(0.0f, 0.0f, 0.0f);
for (int l = 0; l < floor_vrtx.Count - 1; l++)
{
point1 = floor_vrtx[l];
point2 = floor_vrtx[l + 1];
shift1 = floor_vrtx[l] + WW1 * floor_nrml[l];
shift2 = floor_vrtx[l + 1] + WW1 * floor_nrml[l + 1];
PickMPC(floor_nrml[l], point1, shift1, floor_nrml[l + 1], point2, shift2, NeabyMPC1, out List <V6> for_MPC1_V6);
PickMPC(floor_nrml[l], point1, shift1, floor_nrml[l + 1], point2, shift2, NeabyMPC2, out List <V6> for_MPC2_V6);
PickMPC(floor_nrml[l], point1, shift1, floor_nrml[l + 1], point2, shift2, NeabyMPC3, out List <V6> for_MPC3_V6);
for (int ii = 0; ii < for_MPC1_V6.Count; ii++)
{
if (!GlobalMPC1.Contains(for_MPC1_V6[ii].Coordinates))
{
SeenV6_MPC1.Add(for_MPC1_V6[ii]);
V7 tempV7_MPC1 = new V7(for_MPC1_V6[ii], MPC1_num);
SeenV7_MPC1.Add(tempV7_MPC1);
GlobalMPC1.Add(for_MPC1_V6[ii].Coordinates);
GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cleared_sphere.transform.position = for_MPC1_V6[ii].Coordinates;
Destroy(cleared_sphere.GetComponent <SphereCollider>()); // remove collider
cleared_sphere.name = "mpc1 #" + MPC1_num;
var sphereRenderer = cleared_sphere.GetComponent <Renderer>();
sphereRenderer.material = MPC1_mat;
cleared_sphere.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
MPC1_num += 1;
}
}
for (int ii = 0; ii < for_MPC2_V6.Count; ii++)
{
if (!GlobalMPC2.Contains(for_MPC2_V6[ii].Coordinates))
{
SeenV6_MPC2.Add(for_MPC2_V6[ii]);
V7 tempV7_MPC2 = new V7(for_MPC2_V6[ii], MPC2_num);
SeenV7_MPC2.Add(tempV7_MPC2);
GlobalMPC2.Add(for_MPC2_V6[ii].Coordinates);
GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cleared_sphere.transform.position = for_MPC2_V6[ii].Coordinates;
Destroy(cleared_sphere.GetComponent <SphereCollider>()); // remove collider
cleared_sphere.name = "mpc2 #" + MPC2_num;
var sphereRenderer = cleared_sphere.GetComponent <Renderer>();
sphereRenderer.material = MPC2_mat;
cleared_sphere.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
MPC2_num += 1;
}
}
for (int ii = 0; ii < for_MPC3_V6.Count; ii++)
{
if (!GlobalMPC3.Contains(for_MPC3_V6[ii].Coordinates))
{
SeenV6_MPC3.Add(for_MPC3_V6[ii]);
V7 tempV7_MPC3 = new V7(for_MPC3_V6[ii], MPC3_num);
SeenV7_MPC3.Add(tempV7_MPC3);
GlobalMPC3.Add(for_MPC3_V6[ii].Coordinates);
GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cleared_sphere.transform.position = for_MPC3_V6[ii].Coordinates;
Destroy(cleared_sphere.GetComponent <SphereCollider>()); // remove collider
cleared_sphere.name = "mpc3 #" + MPC3_num;
var sphereRenderer = cleared_sphere.GetComponent <Renderer>();
sphereRenderer.material = MPC3_mat;
cleared_sphere.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
MPC3_num += 1;
}
}
area = new Area34(point1, shift1, point2, shift2);
//DrawArea(area);
}
//Area2D(vv1, vv2, out float S11);
}
Debug.Log("Number of seen MPC1 = " + SeenV6_MPC1.Count);
Debug.Log("Number of seen MPC2 = " + SeenV6_MPC2.Count);
Debug.Log("Number of seen MPC3 = " + SeenV6_MPC3.Count);
}
// Start is called before the first frame update
void Start()
{
float t_native = Time.realtimeSinceStartup;
GameObject MPC_Spawner = GameObject.Find("MPC_spawner");
Scatterers_Spawning2 MPC_Script = MPC_Spawner.GetComponent <Scatterers_Spawning2>();
List <Vector3> MPC1 = MPC_Script.MPC1_possiblepositionList;
List <Vector3> MPC2 = MPC_Script.MPC2_possiblepositionList;
List <Vector3> MPC3 = MPC_Script.MPC3_possiblepositionList;
NativeList <V4> MPC1_Native = MPC_Script.MPC1_possiblepositionNativeList;
NativeList <V4> MPC2_Native = MPC_Script.MPC2_possiblepositionNativeList;
NativeList <V4> MPC3_Native = MPC_Script.MPC3_possiblepositionNativeList;
NativeList <V4> DMC_Native = MPC_Script.DMC_possiblepositionNativeList;
NativeArray <Vector3> OBS_Native = MPC_Script.Observation_Points_NativeArray;
NativeList <V5> MPC_Native = MPC_Script.MPC_possiblepositionNativeList;
// Declaring buildings and observation points
Buildings = GameObject.FindGameObjectsWithTag("Reflecting_Obstacles");
// The number of observation points should not be too big, a few is enough
//Observation_Points = GameObject.FindGameObjectsWithTag("Observation_Points");
// Define the main road direction
//Vector3 main_axis = (Observation_Points[0].transform.position - Observation_Points[1].transform.position).normalized;
Vector3 main_axis = (OBS_Native[0] - OBS_Native[1]).normalized;
Vector3 perp_axis = new Vector3(main_axis.z, 0, -main_axis.x);
// subset of the seen Buldings
List <GameObject> Building_list = new List <GameObject>();
// Going through all observation points
for (int k = 0; k < OBS_Native.Length; k++)
{
// analyzing which buidings are seen
for (int b = 0; b < Buildings.Length; b++)
{
Vector3[] vrtx = Buildings[b].GetComponent <MeshFilter>().mesh.vertices;
Vector3[] nrml = Buildings[b].GetComponent <MeshFilter>().mesh.normals;
int seen_vrtx_count = 0;
for (int v = 0; v < vrtx.Length; v++)
{
if (vrtx[v].y == 0)
{
//if (!Physics.Linecast(Observation_Points[k].transform.position, vrtx[v] + 1.1f * nrml[v]))
if (!Physics.Linecast(OBS_Native[k], vrtx[v] + 1.1f * nrml[v]))
{
seen_vrtx_count += 1;
}
}
}
if (seen_vrtx_count != 0)
{
if (!Building_list.Contains(Buildings[b]))
{
Building_list.Add(Buildings[b]);
}
}
}
}
// deactivating nonseen buildings
for (int b = 0; b < Buildings.Length; b++)
{
if (!Building_list.Contains(Buildings[b]))
{
Buildings[b].SetActive(false);
}
}
Debug.Log("The number of seen Buildings = " + Building_list.Count);
List <Vector3> GlobalMPC1 = new List <Vector3>();
List <Vector3> GlobalMPC2 = new List <Vector3>();
List <Vector3> GlobalMPC3 = new List <Vector3>();
List <Vector3> GlobalDMC = new List <Vector3>();
// int inclusion_count = 0;
// analyzing each seen building separately
NativeArray <V6> MPC1_Pick = new NativeArray <V6>(MPC1_Native.Length, Allocator.TempJob);
NativeArray <V6> MPC2_Pick = new NativeArray <V6>(MPC2_Native.Length, Allocator.TempJob);
NativeArray <V6> MPC3_Pick = new NativeArray <V6>(MPC3_Native.Length, Allocator.TempJob);
NativeArray <V6> DMC_Pick = new NativeArray <V6>(DMC_Native.Length, Allocator.TempJob);
// perpendicular directions
NativeArray <Vector3> MPC1_Pick_perp = new NativeArray <Vector3>(MPC1_Native.Length, Allocator.TempJob);
NativeArray <Vector3> MPC2_Pick_perp = new NativeArray <Vector3>(MPC2_Native.Length, Allocator.TempJob);
NativeArray <Vector3> MPC3_Pick_perp = new NativeArray <Vector3>(MPC3_Native.Length, Allocator.TempJob);
NativeArray <Vector3> DMC_Pick_perp = new NativeArray <Vector3>(DMC_Native.Length, Allocator.TempJob);
for (int k = 0; k < Building_list.Count; k++)
{
// writing MPCs into a txt file
//string writePath;
List <string> Obj_List = new List <string>();
Vector3[] vrtx = Building_list[k].GetComponent <MeshFilter>().mesh.vertices;
Vector3[] nrml = Building_list[k].GetComponent <MeshFilter>().mesh.normals;
List <Vector3> floor_vrtx = new List <Vector3>();
List <Vector3> floor_nrml = new List <Vector3>();
var pairs = new List <V6>();
List <Vector3> possible_vrtx = new List <Vector3>();
List <Vector3> possible_nrml = new List <Vector3>();
for (int l = 0; l < vrtx.Length; l++)
{
if (vrtx[l].y == 0 && Mathf.Abs(nrml[l].y) < 0.9)
{
floor_vrtx.Add(vrtx[l]);
floor_nrml.Add(nrml[l]);
// adding coordinates and normals of the vertices into a single object V6 (like a N x 6 matrix)
V6 valid_pair = new V6(vrtx[l], nrml[l]);
pairs.Add(valid_pair);
}
}
// finding the edges of each building
List <Vector3> SortedByX = floor_vrtx.OrderBy(vertex => vertex.x).ToList();
List <Vector3> SortedByZ = floor_vrtx.OrderBy(vertex => vertex.z).ToList();
float x_l = SortedByX[0].x - WW2; // x left
float x_r = SortedByX[SortedByX.Count - 1].x + WW2; // x right
float z_d = SortedByZ[0].z - WW2; // z down
float z_u = SortedByZ[SortedByX.Count - 1].z + WW2; // z up
// This procedure is needed for defining the corner the building for further Diffraction simulation
string building_name = Building_list[k].name;
Vector3 corner1 = new Vector3(0, 0, 0);
Vector3 normal1 = new Vector3(0, 0, 0);
Vector3 perpen1 = new Vector3(0, 0, 0);
Vector3 corner2 = new Vector3(0, 0, 0);
Vector3 normal2 = new Vector3(0, 0, 0);
Vector3 perpen2 = new Vector3(0, 0, 0);
if (building_name == "Building258")
{
Debug.Log(building_name);
corner1 = SortedByX[2];
corner2 = SortedByX[6];
GameObject Corner1 = Instantiate(CornerPrefab, corner1, Quaternion.identity);
GameObject Corner2 = Instantiate(MPC1_Prefab, corner2, Quaternion.identity);
int corner1_count = 0;
for (int v = 0; v < floor_vrtx.Count; v++)
{
if (corner1 == floor_vrtx[v])
{
if (corner1_count == 0)
{
normal1 = floor_nrml[v]; // I use the assumption that the vertex is used only twice
corner1_count = 1;
}
}
if (corner2 == floor_vrtx[v])
{
normal2 = floor_nrml[v]; // I use the assumption that the vertex is used only twice
}
}
normal1 = normal1.normalized;
perpen1 = new Vector3(-normal1.z, 0, normal1.x);
Debug.DrawLine(corner1, corner1 + 5 * normal1, Color.red, 30f);
normal2 = normal2.normalized;
perpen2 = new Vector3(-normal2.z, 0, normal2.x);
Debug.DrawLine(corner2, corner2 + 5 * normal2, Color.red, 30f);
Active_CornersNormalsPerpendiculars.Add(corner1);
Active_CornersNormalsPerpendiculars.Add(normal1);
Active_CornersNormalsPerpendiculars.Add(perpen1);
Active_CornersNormalsPerpendiculars.Add(corner2);
Active_CornersNormalsPerpendiculars.Add(normal2);
Active_CornersNormalsPerpendiculars.Add(perpen2);
// this is done to model single edge building (keep in mind, multipath go through the angle)
// Vector3 corner_test = (corner1 + corner2) / 2 + 3.0f * (normal1 + normal2) / 2;
Vector3 corner_test = new Vector3(53.64f, 0.0f, -26.89f);
GameObject Corner_Test = Instantiate(CornerPrefab, corner_test, Quaternion.identity);
Active_CornersNormalsPerpendiculars.Add(corner_test);
}
/*
* if (building_name == "Building321")
* {
* Debug.Log(building_name);
* corner321 = SortedByX[SortedByX.Count - 1];
*
* GameObject Corner321 = Instantiate(CornerPrefab, corner321, Quaternion.identity);
*
* for (int v = 0; v < floor_vrtx.Count; v++)
* {
* if (corner321 == floor_vrtx[v])
* {
* normal321 += floor_nrml[v]; // I use the assumption that the vertex is used only twice
* }
* }
* normal321 = normal321.normalized;
* perpen321 = new Vector3(-normal321.z, 0, normal321.x);
* Debug.DrawLine(corner321, corner321 + 5 * normal321, Color.red, 30f);
*
* Active_CornersNormalsPerpendiculars.Add(corner321);
* Active_CornersNormalsPerpendiculars.Add(normal321);
* Active_CornersNormalsPerpendiculars.Add(perpen321);
* }
* if (building_name == "Building334")
* {
* Debug.Log(building_name);
* corner334 = SortedByX[0];
* GameObject Corner334 = Instantiate(CornerPrefab, corner334, Quaternion.identity);
*
* for (int v = 0; v < floor_vrtx.Count; v++)
* {
* if (corner334 == floor_vrtx[v])
* {
* normal334 += floor_nrml[v]; // I use the assumption that the vertex is used only twice
* }
* }
* normal334 = normal334.normalized;
* perpen334 = new Vector3(-normal334.z, 0, normal334.x);
* Debug.DrawLine(corner334, corner334 + 5 * normal334, Color.red, 30f);
*
* Active_CornersNormalsPerpendiculars.Add(corner334);
* Active_CornersNormalsPerpendiculars.Add(normal334);
* Active_CornersNormalsPerpendiculars.Add(perpen334);
* }
*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Defining areas around building where scatterers can be located
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// defining necessary elements for the polygon that connects the last and the first vertices
Vector3 n1_0 = floor_nrml[floor_vrtx.Count - 1];
Vector3 p1_0 = floor_vrtx[floor_vrtx.Count - 1];
Vector3 s1_0 = floor_vrtx[floor_vrtx.Count - 1] + WW1 * floor_nrml[floor_vrtx.Count - 1];
Vector3 s1_0_dmc = floor_vrtx[floor_vrtx.Count - 1] + WW2 * floor_nrml[floor_vrtx.Count - 1];
Vector3 n2_0 = floor_nrml[0];
Vector3 p2_0 = floor_vrtx[0];
Vector3 s2_0 = floor_vrtx[0] + WW1 * floor_nrml[0];
Vector3 s2_0_dmc = floor_vrtx[0] + WW2 * floor_nrml[0];
Area34 area = new Area34(p1_0, s1_0, p2_0, s2_0);
//float t1 = Time.realtimeSinceStartup;
// MPC1
PickMPCParallel pickMPCParallel1 = new PickMPCParallel
{
n1 = n1_0,
p1 = p1_0,
s1 = s1_0,
n2 = n2_0,
p2 = p2_0,
s2 = s2_0,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = MPC1_Native,
MPC_V6 = MPC1_Pick,
MPC_perp = MPC1_Pick_perp,
};
JobHandle jobHandle_Pick1 = pickMPCParallel1.Schedule(MPC1_Native.Length, 100);
// MPC2
PickMPCParallel pickMPCParallel2 = new PickMPCParallel
{
n1 = n1_0,
p1 = p1_0,
s1 = s1_0,
n2 = n2_0,
p2 = p2_0,
s2 = s2_0,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = MPC2_Native,
MPC_V6 = MPC2_Pick,
MPC_perp = MPC2_Pick_perp,
};
JobHandle jobHandle_Pick2 = pickMPCParallel2.Schedule(MPC2_Native.Length, 100, jobHandle_Pick1);
// MPC3
PickMPCParallel pickMPCParallel3 = new PickMPCParallel
{
n1 = n1_0,
p1 = p1_0,
s1 = s1_0,
n2 = n2_0,
p2 = p2_0,
s2 = s2_0,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = MPC3_Native,
MPC_V6 = MPC3_Pick,
MPC_perp = MPC3_Pick_perp,
};
JobHandle jobHandle_Pick3 = pickMPCParallel3.Schedule(MPC3_Native.Length, 100, jobHandle_Pick2);
// DMC
PickMPCParallel pickMPCParallel4 = new PickMPCParallel
{
n1 = n1_0,
p1 = p1_0,
s1 = s1_0_dmc,
n2 = n2_0,
p2 = p2_0,
s2 = s2_0_dmc,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = DMC_Native,
MPC_V6 = DMC_Pick,
MPC_perp = DMC_Pick_perp,
};
JobHandle jobHandle_Pick4 = pickMPCParallel4.Schedule(DMC_Native.Length, 100, jobHandle_Pick3);
jobHandle_Pick1.Complete();
jobHandle_Pick2.Complete();
jobHandle_Pick3.Complete();
jobHandle_Pick4.Complete();
//Debug.Log("Check Time t1: " + ((Time.realtimeSinceStartup - t1) * 1000f) + " ms");
// draw areas for all vertices
Vector3 point1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 point2 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 shift1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 shift2 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 dmc_shift1 = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 dmc_shift2 = new Vector3(0.0f, 0.0f, 0.0f);
for (int l = 0; l < floor_vrtx.Count - 1; l++)
{
point1 = floor_vrtx[l];
point2 = floor_vrtx[l + 1];
shift1 = floor_vrtx[l] + WW1 * floor_nrml[l];
shift2 = floor_vrtx[l + 1] + WW1 * floor_nrml[l + 1];
dmc_shift1 = floor_vrtx[l] + WW2 * floor_nrml[l];
dmc_shift2 = floor_vrtx[l + 1] + WW2 * floor_nrml[l + 1];
Area34 area_forloop = new Area34(point1, dmc_shift1, point2, dmc_shift2);
//DrawArea(area_forloop);
// MPC1
PickMPCParallel pickMPCParallel_for = new PickMPCParallel
{
n1 = floor_nrml[l],
p1 = point1,
s1 = shift1,
n2 = floor_nrml[l + 1],
p2 = point2,
s2 = shift2,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = MPC1_Native,
MPC_V6 = MPC1_Pick,
MPC_perp = MPC1_Pick_perp,
};
JobHandle jobHandle_Pick1_for = pickMPCParallel_for.Schedule(MPC1_Native.Length, 100);
// MPC2
PickMPCParallel pickMPCParallel2_for = new PickMPCParallel
{
n1 = floor_nrml[l],
p1 = point1,
s1 = shift1,
n2 = floor_nrml[l + 1],
p2 = point2,
s2 = shift2,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = MPC2_Native,
MPC_V6 = MPC2_Pick,
MPC_perp = MPC2_Pick_perp,
};
JobHandle jobHandle_Pick2_for = pickMPCParallel2_for.Schedule(MPC2_Native.Length, 100, jobHandle_Pick1_for);
// MPC3
PickMPCParallel pickMPCParallel3_for = new PickMPCParallel
{
n1 = floor_nrml[l],
p1 = point1,
s1 = shift1,
n2 = floor_nrml[l + 1],
p2 = point2,
s2 = shift2,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = MPC3_Native,
MPC_V6 = MPC3_Pick,
MPC_perp = MPC3_Pick_perp,
};
JobHandle jobHandle_Pick3_for = pickMPCParallel3_for.Schedule(MPC3_Native.Length, 100, jobHandle_Pick2_for);
// DMC
PickMPCParallel pickMPCParallel4_for = new PickMPCParallel
{
n1 = floor_nrml[l],
p1 = point1,
s1 = dmc_shift1,
n2 = floor_nrml[l + 1],
p2 = point2,
s2 = dmc_shift2,
Xleft = x_l,
Xright = x_r,
Zdown = z_d,
Zup = z_u,
MPC_array = DMC_Native,
MPC_V6 = DMC_Pick,
MPC_perp = DMC_Pick_perp,
};
JobHandle jobHandle_Pick4_for = pickMPCParallel4_for.Schedule(DMC_Native.Length, 100, jobHandle_Pick3_for);
jobHandle_Pick1_for.Complete();
jobHandle_Pick2_for.Complete();
jobHandle_Pick3_for.Complete();
jobHandle_Pick4_for.Complete();
}
}
//float t_seq = Time.realtimeSinceStartup;
// DMC
int inclusion_num0 = 0;
for (int ii = 0; ii < DMC_Native.Length; ii++)
{
if (DMC_Native[ii].Inclusion == 1)
{
inclusion_num0 += 1;
ActiveV6_DMC_NativeList.Add(DMC_Pick[ii]); // DMCs only
ActiveV6_MPC_NativeList.Add(DMC_Pick[ii]); // all MPCs
// MPC perpendicular directions
Active_DMC_Perpendiculars.Add(DMC_Pick_perp[ii]);
Active_MPC_Perpendiculars.Add(DMC_Pick_perp[ii]);
if (MPC_visualizer_ECS == true)
{
GameObject DMC_clone = Instantiate(DMC_Prefab, DMC_Native[ii].Coordinates, Quaternion.identity);
//GameObject cleared_sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//cleared_sphere.transform.position = DMC_Native[ii].Coordinates;
//Destroy(cleared_sphere.GetComponent<SphereCollider>()); // remove collider
//cleared_sphere.name = "DMC #" + (inclusion_num4 - 1);
//Debug.DrawLine(DMC_Pick[ii].Coordinates, DMC_Pick[ii].Coordinates + 5*DMC_Pick[ii].Normal, Color.red, 30f);
}
}
}
// MPC1
int inclusion_num1 = 0;
for (int ii = 0; ii < MPC1_Native.Length; ii++)
{
if (MPC1_Native[ii].Inclusion == 1)
{
inclusion_num1 += 1;
ActiveV6_MPC1_NativeList.Add(MPC1_Pick[ii]);
ActiveV6_MPC_NativeList.Add(MPC1_Pick[ii]);
// MPC perpendicular directions
Active_MPC1_Perpendiculars.Add(MPC1_Pick_perp[ii]);
Active_MPC_Perpendiculars.Add(MPC1_Pick_perp[ii]);
if (MPC_visualizer_ECS == true)
{
GameObject MPC1_clone = Instantiate(MPC1_Prefab, MPC1_Native[ii].Coordinates, Quaternion.identity);
}
}
}
// MPC2
int inclusion_num2 = 0;
for (int ii = 0; ii < MPC2_Native.Length; ii++)
{
if (MPC2_Native[ii].Inclusion == 1)
{
ActiveV6_MPC2_NativeList.Add(MPC2_Pick[ii]);
ActiveV6_MPC_NativeList.Add(MPC2_Pick[ii]);
// MPC perpendicular directions
Active_MPC2_Perpendiculars.Add(MPC2_Pick_perp[ii]);
Active_MPC_Perpendiculars.Add(MPC2_Pick_perp[ii]);
if (MPC_visualizer_ECS == true)
{
GameObject MPC2_clone = Instantiate(MPC2_Prefab, MPC2_Native[ii].Coordinates, Quaternion.identity);
MPC2_clone.name = "MPC2 # " + inclusion_num2;
//Debug.DrawLine(MPC2_Pick[ii].Coordinates, MPC2_Pick[ii].Coordinates + 5 * MPC2_Pick[ii].Normal, Color.cyan, 10f);
//Debug.DrawLine(MPC2_Pick[ii].Coordinates, MPC2_Pick[ii].Coordinates + 5 * MPC2_Pick_perp[ii], Color.yellow, 10f);
}
inclusion_num2 += 1;
}
}
// MPC3
int inclusion_num3 = 0;
for (int ii = 0; ii < MPC3_Native.Length; ii++)
{
if (MPC3_Native[ii].Inclusion == 1)
{
ActiveV6_MPC3_NativeList.Add(MPC3_Pick[ii]);
ActiveV6_MPC_NativeList.Add(MPC3_Pick[ii]);
// MPC perpendicular directions
Active_MPC3_Perpendiculars.Add(MPC3_Pick_perp[ii]);
Active_MPC_Perpendiculars.Add(MPC3_Pick_perp[ii]);
if (MPC_visualizer_ECS == true)
{
GameObject MPC3_clone = Instantiate(MPC3_Prefab, MPC3_Native[ii].Coordinates, Quaternion.identity);
MPC3_clone.name = "MPC3 # " + inclusion_num3;
//Debug.DrawLine(MPC3_Pick[ii].Coordinates, MPC3_Pick[ii].Coordinates + 5 * MPC3_Pick[ii].Normal, Color.cyan, 10f);
//Debug.DrawLine(MPC3_Pick[ii].Coordinates, MPC3_Pick[ii].Coordinates + 5 * MPC3_Pick_perp[ii], Color.yellow, 10f);
}
inclusion_num3 += 1;
}
}
//Debug.Log("Check Time for Sequ: " + ((Time.realtimeSinceStartup - t_seq) * 1000f) + " ms");
Debug.Log("DMC " + inclusion_num0 + "; MPC1 " + inclusion_num1 + "; MPC2 " + inclusion_num2 + "; MPC3 " + inclusion_num3);
#region Generating attenuation coefficients for MPCs
// Power generation for MPCs
ActiveV6_DMC_Power = new NativeArray <float>(ActiveV6_DMC_NativeList.Length, Allocator.Persistent);
ActiveV6_MPC1_Power = new NativeArray <float>(ActiveV6_MPC1_NativeList.Length, Allocator.Persistent);
ActiveV6_MPC2_Power = new NativeArray <float>(ActiveV6_MPC2_NativeList.Length, Allocator.Persistent);
ActiveV6_MPC3_Power = new NativeArray <float>(ActiveV6_MPC3_NativeList.Length, Allocator.Persistent);
int MPC_length = ActiveV6_DMC_NativeList.Length + ActiveV6_MPC1_NativeList.Length + ActiveV6_MPC2_NativeList.Length + ActiveV6_MPC3_NativeList.Length;
ActiveV6_MPC_Power = new NativeArray <float>(MPC_length, Allocator.Persistent);
//int clbrcoef = 10;
Vector2 DMCPower = new Vector2(-80, -68); // + new Vector2(1,1) * clbrcoef; // (Mathf.Pow(10, (-80/20)), Mathf.Pow(10, (-68/20))); // (-80, -68)[dB] % Diffuse 1st)
Vector2 MPC1Power = new Vector2(-65, -48); // (Mathf.Pow(10, (-65/20)), Mathf.Pow(10, (-48/20))); // (-65, -48)[dB] % 1st
Vector2 MPC2Power = new Vector2(-70, -59); // (Mathf.Pow(10, (-70/20)), Mathf.Pow(10, (-59/20))); // (-70, -59)[dB] % 2nd
Vector2 MPC3Power = new Vector2(-75, -65); // (Mathf.Pow(10, (-75/20)), Mathf.Pow(10, (-65/20))); // (-75, -65)[dB] % 3rd
// this solution comes from https://forum.unity.com/threads/mathematics-random-with-in-ijobprocesscomponentdata.598192/#post-4009273
NativeArray <Unity.Mathematics.Random> rngs = new NativeArray <Unity.Mathematics.Random>(JobsUtility.MaxJobThreadCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < JobsUtility.MaxJobThreadCount; i++)
{
rngs[i] = new Unity.Mathematics.Random((uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue));
}
MPCPowerGeneration dmcPowerGeneration = new MPCPowerGeneration
{
rngs = rngs,
MinMax = DMCPower,
Array = ActiveV6_DMC_Power,
};
JobHandle power0 = dmcPowerGeneration.Schedule(ActiveV6_DMC_Power.Length, 64);
power0.Complete();
for (int i = 0; i < ActiveV6_DMC_Power.Length; i++)
{
ActiveV6_MPC_Power[i] = ActiveV6_DMC_Power[i];
}
MPCPowerGeneration mpc1PowerGeneration = new MPCPowerGeneration
{
rngs = rngs,
MinMax = MPC1Power,
Array = ActiveV6_MPC1_Power,
};
JobHandle power1 = mpc1PowerGeneration.Schedule(ActiveV6_MPC1_Power.Length, 64);
power1.Complete();
for (int i = 0; i < ActiveV6_MPC1_Power.Length; i++)
{
ActiveV6_MPC_Power[i + ActiveV6_DMC_Power.Length] = ActiveV6_MPC1_Power[i];
}
MPCPowerGeneration mpc2PowerGeneration = new MPCPowerGeneration
{
rngs = rngs,
MinMax = MPC2Power,
Array = ActiveV6_MPC2_Power,
};
JobHandle power2 = mpc2PowerGeneration.Schedule(ActiveV6_MPC2_Power.Length, 64);
power2.Complete();
for (int i = 0; i < ActiveV6_MPC2_Power.Length; i++)
{
ActiveV6_MPC_Power[i + ActiveV6_DMC_Power.Length + ActiveV6_MPC1_Power.Length] = Mathf.Pow(ActiveV6_MPC2_Power[i], 0.5f); // It seems that Carl uses only one multiplication to the coefficient
ActiveV6_MPC2_Power[i] = Mathf.Pow(ActiveV6_MPC2_Power[i], 0.5f);
float asd = ActiveV6_MPC2_Power[i];
float zxc = Mathf.Pow(asd, 0.5f);
//float qwe = 1.0f;
}
MPCPowerGeneration mpc3PowerGeneration = new MPCPowerGeneration
{
rngs = rngs,
MinMax = MPC3Power,
Array = ActiveV6_MPC3_Power,
};
JobHandle power3 = mpc3PowerGeneration.Schedule(ActiveV6_MPC3_Power.Length, 64);
power3.Complete();
for (int i = 0; i < ActiveV6_MPC3_Power.Length; i++)
{
float asd = ActiveV6_MPC3_Power[i];
float zxc = Mathf.Pow(ActiveV6_MPC3_Power[i], 0.3333f);
ActiveV6_MPC_Power[i + ActiveV6_DMC_Power.Length + ActiveV6_MPC1_Power.Length + ActiveV6_MPC2_Power.Length] = Mathf.Pow(ActiveV6_MPC3_Power[i], 0.3333f); // It seems that Carl uses only one multiplication to the coefficient
ActiveV6_MPC3_Power[i] = Mathf.Pow(ActiveV6_MPC3_Power[i], 0.3333f);
}
#endregion
MPC1_Pick.Dispose();
MPC2_Pick.Dispose();
MPC3_Pick.Dispose();
DMC_Pick.Dispose();
MPC1_Pick_perp.Dispose();
MPC2_Pick_perp.Dispose();
MPC3_Pick_perp.Dispose();
DMC_Pick_perp.Dispose();
rngs.Dispose();
Debug.Log("Check Time t_native: " + ((Time.realtimeSinceStartup - t_native) * 1000f) + " ms");
}
