public Satisfiability(HoloAd config)
{
maxX = config.maxX;
maxY = config.maxY;
maxZ = config.maxZ;
ClearSatData();
}
public void ShowSatisfiabilityGraph(Satisfiability satisfiability, HoloAd config)
{
if (satisfiability.GetLength() == maxX * maxY * maxZ)
{
for (int index = 0; index < maxX * maxY * maxZ; index++)
{
float sat = satisfiability.cells[index];
if (float.IsNaN(sat))
{
sat = 0f;
}
Renderer renderer = cells[index].GetComponent <Renderer>();
if (sat < config.minVisibleSatisfiability)
{
renderer.enabled = false;
}
else
{
renderer.enabled = true;
renderer.material.color = new Color(sat, sat, sat, sat);
}
}
}
else
{
ReconstructVisuals(config);
ShowSatisfiabilityGraph(satisfiability, config);
}
}
public void SetConfig(HoloAd config)
{
this.matrixScale = config.matrixScale;
this.prefabMatrixCell = config.prefabMatrixCell;
this.minVisibleSatisfiability = config.minVisibleSatisfiability;
cells = new GameObject[0];
}
public List <Vector3[]>[] trigsInCells; // v1, v2, v3, normal
public void RecalculateMesh(HoloAd config)
{
trigsInCells = new List <Vector3[]> [config.maxX * config.maxY * config.maxZ];
for (int i = 0; i < config.maxX * config.maxY * config.maxZ; i++)
{
trigsInCells[i] = new List <Vector3[]>();
}
int childCount = config.spatialMapping.transform.childCount;
for (int i = 0; i < childCount; i++)
{
GameObject child = config.spatialMapping.transform.GetChild(i).gameObject;
Mesh mesh = child.GetComponent <MeshFilter>().mesh;
Vector3[] meshVerts = mesh.vertices;
int[] meshTrigs = mesh.triangles;
int trigsCount = meshTrigs.Length;
for (int trigIndex = 0; trigIndex < trigsCount; trigIndex += 3)
{
int[] verts = { meshTrigs[trigIndex], meshTrigs[trigIndex + 1], meshTrigs[trigIndex + 2] };
foreach (int v in verts)
{
Vector3 vec = config.room.transform.InverseTransformPoint(child.transform.TransformPoint(meshVerts[v]));
float cubeSide = config.matrixScale;
int[] matCords =
{
(int)System.Math.Round(config.room.transform.localScale.x * (vec.x + .5f) / cubeSide),
(int)System.Math.Round(config.room.transform.localScale.y * (vec.y + .5f) / cubeSide),
(int)System.Math.Round(config.room.transform.localScale.z * (vec.z + .5f) / cubeSide)
};
if (config.IsCellInMatrix(matCords[0], matCords[1], matCords[2]))
{
Vector3[] trig = new Vector3[] {
config.room.transform.InverseTransformPoint(child.transform.TransformPoint(meshVerts[verts[0]])),
config.room.transform.InverseTransformPoint(child.transform.TransformPoint(meshVerts[verts[1]])),
config.room.transform.InverseTransformPoint(child.transform.TransformPoint(meshVerts[verts[2]])),
Vector3.Cross(meshVerts[verts[0]] - meshVerts[verts[2]], meshVerts[verts[0]] - meshVerts[verts[1]]).normalized
};
trigsInCells[matCords[0] + config.maxX * matCords[1] + config.maxX * config.maxY * matCords[2]].Add(trig);
break;
}
}
}
}
}
public void ReconstructVisuals(HoloAd config)
{
DestroyVisuals();
matrixScale = config.matrixScale;
this.prefabMatrixCell = config.prefabMatrixCell;
Vector3 matSize = config.room.transform.transform.lossyScale / config.matrixScale;
matrix = new GameObject();
matrix.name = "matrix";
maxX = (int)System.Math.Ceiling(matSize.x);
maxY = (int)System.Math.Ceiling(matSize.y);
maxZ = (int)System.Math.Ceiling(matSize.z);
matrix.transform.localScale = new Vector3(config.room.transform.lossyScale.x / matSize.x, config.room.transform.lossyScale.y / matSize.y, config.room.transform.lossyScale.z / matSize.z);
matrix.transform.rotation = config.room.transform.rotation;
cells = new GameObject[maxX * maxY * maxZ];
for (int x = 0; x < maxX; x++)
{
for (int y = 0; y < maxY; y++)
{
for (int z = 0; z < maxZ; z++)
{
GameObject cell = GameObject.Instantiate(prefabMatrixCell);
cell.name = "cell: " + x + " " + y + " " + z;
cell.transform.position = config.room.transform.position;
cell.transform.rotation = config.room.transform.rotation;
cell.transform.Translate(new Vector3(
-matSize.x / 2f * matrixScale + x * matrixScale + matrixScale / 2f,
-matSize.y / 2f * matrixScale + y * matrixScale + matrixScale / 2f,
-matSize.z / 2f * matrixScale + z * matrixScale + matrixScale / 2f
));
cell.transform.localScale = new Vector3(matrixScale, matrixScale, matrixScale);
cell.transform.SetParent(matrix.transform);
cells[x + maxX * y + maxX * maxY * z] = cell;
}
}
}
}
public void TestCriterion(HoloAd.Criterion[] testCriterion, HoloAd config)
{
ClearSatData();
Transform room = config.room.transform;
List <HoloAd.Criterion> comCriterion = new List <HoloAd.Criterion>(), criterion = new List <HoloAd.Criterion>();
float maxSat = 0f, maxComSat = 0f;
foreach (HoloAd.Criterion crit in testCriterion)
{
if (crit.type == 7)
{
maxComSat += crit.importance;
comCriterion.Add(crit);
}
else
{
maxSat += crit.importance;
criterion.Add(crit);
}
}
for (int x = 0; x < maxX; x++)
{
for (int y = 0; y < maxY; y++)
{
for (int z = 0; z < maxZ; z++)
{
List <Vector3[]> triangles = config.meshAnalyzer.trigsInCells[CalcIndex(x, y, z)];
float cellSat = 0f;
foreach (HoloAd.Criterion crit in criterion)
{
float result = 0f;
switch (crit.type)
{
case 0: result = 1; break;
case 1:
{
foreach (Vector3[] trig in triangles)
{
float trigSat = (trig[0].y + trig[1].y + trig[2].y) / 3f + room.lossyScale.y / 2f;
result += trigSat > (crit.data.x) ? (trigSat < (crit.data.y) ? 1f : 0f) : 0f;
}
result = result / triangles.Count;
break;
}
case 2:
{
foreach (Vector3[] trig in triangles)
{
float trigSat = 0f;
float ceilCord = room.lossyScale.y;
for (int i = 0; i < 3; i++)
{
trigSat += ceilCord - trig[i].y > crit.data.x && ceilCord - trig[i].y < crit.data.y ? 1f : 0f;
}
result += trigSat / 3f;
}
result = result / triangles.Count;
break;
}
case 3:
{
break;
}
case 4: break;
case 5: //будет реализовываться движком
{
result = 1;
break;
}
case 6:
{
float allTrigsSurf = 0f;
foreach (Vector3[] trig in triangles)
{
float trigS = Vector3.Cross(trig[0] - trig[2], trig[0] - trig[1]).magnitude / 2f;
allTrigsSurf += trigS;
Vector3 normal = new Vector3(crit.data.x, crit.data.y, crit.data.z).normalized; //т.к. вбивается из юнити, чтобы не париться с длинами
if (trig[3].x - normal.x < crit.data.w &&
trig[3].y - normal.y < crit.data.w &&
trig[3].z - normal.z < crit.data.w)
{
result += trigS;
}
}
result = result / allTrigsSurf;
break;
}
}
cellSat += crit.importance * result;
}
SetCellSat(cellSat / maxSat, x, y, z);
}
}
}
if (comCriterion.Count > 0)
{
int len = GetLength();
float[] comCellsSat = new float[len];
for (int x = 0; x < maxX; x++)
{
for (int y = 0; y < maxY; y++)
{
for (int z = 0; z < maxZ; z++)
{
float result = 0f;
foreach (HoloAd.Criterion crit in comCriterion)
{
Vector3Int shift = new Vector3Int(
(int)System.Math.Round(x + crit.data.x),
(int)System.Math.Round(y + crit.data.y),
(int)System.Math.Round(z + crit.data.z)
);
if (IsCellInMatrix(shift))
{
result += GetCellSat(shift) * crit.importance;
}
}
comCellsSat[CalcIndex(x, y, z)] = result;
}
}
}
for (int i = 0; i < len; i++)
{
cells[i] = (comCellsSat[i] + cells[i] * maxSat) / (maxSat + maxComSat);
}
}
}
