void MapDataThread(float edgeSize, int subdivisions, Vector3 position, CustomImprovedNoise noise, Action <MapData> callback,
Dictionary <string, CellEdge> edgeDictionary,
Dictionary <string, CellEdge> edgeDictionaryOrphans
)
{
MapData mapData = GenerateTerrainData(edgeSize, subdivisions, position, noise, edgeDictionary, edgeDictionaryOrphans);
lock (mapDataThreadInfoQueue) {
mapDataThreadInfoQueue.Enqueue(new MapThreadInfo <MapData>(callback, mapData, edgeDictionary, edgeDictionaryOrphans));
}
}
public void RequestMapData(float edgeSize, int subdivisions, Vector3 position, CustomImprovedNoise noise,
Action <MapData> callback, Dictionary <string, CellEdge> edgeDictionary,
Dictionary <string, CellEdge> edgeDictionaryXPlusNormalPatch,
Dictionary <string, CellEdge> edgeDictionaryYPlusNormalPatch,
Dictionary <string, CellEdge> edgeDictionaryZPlusNormalPatch
)
{
ThreadStart threadStart = delegate {
MapDataThread(edgeSize, subdivisions, position, noise, callback, edgeDictionary,
edgeDictionaryXPlusNormalPatch, edgeDictionaryYPlusNormalPatch, edgeDictionaryZPlusNormalPatch);
};
new Thread(threadStart).Start();
}
void Start()
{
meshGenerator = gameObject.AddComponent <MeshGenerator>();
int seed = 151178;
//int seed = (int)UnityEngine.Random.value;
perlinNoise1 = new Perlin(frequency, lacunarity, persistence, octaves, seed, quality);
perlinNoise = new Perlin(frequency, lacunarity, persistence, octaves, seed, quality);
cnoise = new CustomImprovedNoise(151178);
root_cube = new GameObject();
rootChunk = root_cube.AddComponent <Chunk>();
rootChunk.transform.parent = gameObject.transform;
rootChunk.createCube(null, this, radius, 0, 0, 0, 0, "root");
}
public MapData GenerateTerrainData(float size, int subdivisions, Vector3 position, CustomImprovedNoise noise,
Dictionary <string, CellEdge> edgeDictionary,
Dictionary <string, CellEdge> edgeDictionaryXPlusNormalPatch,
Dictionary <string, CellEdge> edgeDictionaryYPlusNormalPatch,
Dictionary <string, CellEdge> edgeDictionaryZPlusNormalPatch
)
{
this.position = position;
float increment = size / subdivisions;
int flagIndex = 0;
//float treshold = 0.4f;
float treshold = DCManager.radius * 0.55f;
Vector3 centerPoint;
int i, x, y, z;
Vector3[] edgeVertex;
List <CellEdge> edgeList = new List <CellEdge>();
int numEdgesWithIntersections = 0;
MapData mapData = new MapData();
Vector3[] cube;
float[] noiseCube;
// spigoli interni
for (x = 0; x < subdivisions; x++)
{
for (y = 0; y < subdivisions; y++)
{
for (z = 0; z < subdivisions; z++)
{
edgeList.Clear();
cube = new Vector3[8];
noiseCube = new float[8];
edgeVertex = new Vector3[12];
numEdgesWithIntersections = 0;
flagIndex = 0;
Vector3 v0 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v1 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v2 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v3 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v4 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
Vector3 v5 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v6 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v7 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
cube[0] = v0;
cube[1] = v1;
cube[2] = v2;
cube[3] = v3;
cube[4] = v4;
cube[5] = v5;
cube[6] = v6;
cube[7] = v7;
for (i = 0; i < 8; i++)
{
noiseCube[i] = DCManager.radius - (cube[i] + position).magnitude;
if (noiseCube[i] <= treshold)
{
flagIndex |= 1 << i;
}
}
if (flagIndex == 0 || flagIndex == 255)
{
continue;
}
// prepara gli spigoli e ordinali in un dizionario
edgeList.Add(new CellEdge(v0, v1, noiseCube[0], noiseCube[1], position, treshold));
edgeList.Add(new CellEdge(v2, v3, noiseCube[2], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v4, v5, noiseCube[4], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v6, v7, noiseCube[6], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v1, v5, noiseCube[1], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v0, v4, noiseCube[0], noiseCube[4], position, treshold));
edgeList.Add(new CellEdge(v2, v6, noiseCube[2], noiseCube[6], position, treshold));
edgeList.Add(new CellEdge(v3, v7, noiseCube[3], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v0, v3, noiseCube[0], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v1, v2, noiseCube[1], noiseCube[2], position, treshold));
edgeList.Add(new CellEdge(v4, v7, noiseCube[4], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v5, v6, noiseCube[5], noiseCube[6], position, treshold));
// per ogni cubo trova quanti spigoli hanno intersezioni
numEdgesWithIntersections = 0;
centerPoint = new Vector3();
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionary);
numEdgesWithIntersections++;
centerPoint += ce.intersectionPoint;
}
}
if (numEdgesWithIntersections == 0 || numEdgesWithIntersections == 8)
{
continue;
}
centerPoint = centerPoint / numEdgesWithIntersections;
// ora che sappiamo quanti spigoli hanno intersezioni calcola il punto medio tra loro e settalo come punto centrale della cella
// dual contour - per infighettarlo qua dovresti applicare la QEF, invece del punto medio tra gli spigoli che hanno intersezioni
int k = 0;
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionary);
c.cells[k] = centerPoint;
}
k++;
if (k > 3)
{
k = 0;
}
}
}
}
} // fine del mega ciclo
///////////////
// spigoli esterni X+
for (x = subdivisions; x < subdivisions + 1; x++)
{
for (y = 0; y < subdivisions + 1; y++)
{
for (z = 0; z < subdivisions + 1; z++)
{
edgeList.Clear();
cube = new Vector3[8];
noiseCube = new float[8];
edgeVertex = new Vector3[12];
numEdgesWithIntersections = 0;
flagIndex = 0;
Vector3 v0 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v1 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v2 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v3 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v4 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
Vector3 v5 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v6 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v7 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
cube[0] = v0;
cube[1] = v1;
cube[2] = v2;
cube[3] = v3;
cube[4] = v4;
cube[5] = v5;
cube[6] = v6;
cube[7] = v7;
for (i = 0; i < 8; i++)
{
noiseCube[i] = DCManager.radius - (cube[i] + position).magnitude;
if (noiseCube[i] <= treshold)
{
flagIndex |= 1 << i; // flagIndex = flagIndex | 1<<i
}
//if(cube[i])
}
if (flagIndex == 0 || flagIndex == 255)
{
continue;
}
// prepara gli spigoli e ordinali in un dizionario
edgeList.Add(new CellEdge(v0, v1, noiseCube[0], noiseCube[1], position, treshold));
edgeList.Add(new CellEdge(v2, v3, noiseCube[2], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v4, v5, noiseCube[4], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v6, v7, noiseCube[6], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v1, v5, noiseCube[1], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v0, v4, noiseCube[0], noiseCube[4], position, treshold));
edgeList.Add(new CellEdge(v2, v6, noiseCube[2], noiseCube[6], position, treshold));
edgeList.Add(new CellEdge(v3, v7, noiseCube[3], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v0, v3, noiseCube[0], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v1, v2, noiseCube[1], noiseCube[2], position, treshold));
edgeList.Add(new CellEdge(v4, v7, noiseCube[4], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v5, v6, noiseCube[5], noiseCube[6], position, treshold));
// per ogni cubo trova quanti spigoli hanno intersezioni
numEdgesWithIntersections = 0;
centerPoint = new Vector3();
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryXPlusNormalPatch);
numEdgesWithIntersections++;
centerPoint += ce.intersectionPoint;
}
}
if (numEdgesWithIntersections == 0 || numEdgesWithIntersections == 8)
{
continue;
}
centerPoint = centerPoint / numEdgesWithIntersections;
// ora che sappiamo quanti spigoli hanno intersezioni calcola il punto medio tra loro e settalo come punto centrale della cella
// dual contour - per infighettarlo qua dovresti applicare la QEF, invece del punto medio tra gli spigoli che hanno intersezioni
int k = 0;
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryXPlusNormalPatch);
c.cells[k] = centerPoint;
}
k++;
if (k > 3)
{
k = 0;
}
}
}
}
}
/////////////////
// spigoli esterni Y+
for (x = 0; x < subdivisions; x++)
{
for (y = subdivisions; y < subdivisions + 1; y++)
{
for (z = 0; z < subdivisions; z++)
{
edgeList.Clear();
cube = new Vector3[8];
noiseCube = new float[8];
edgeVertex = new Vector3[12];
numEdgesWithIntersections = 0;
flagIndex = 0;
Vector3 v0 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v1 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v2 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v3 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v4 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
Vector3 v5 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v6 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v7 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
cube[0] = v0;
cube[1] = v1;
cube[2] = v2;
cube[3] = v3;
cube[4] = v4;
cube[5] = v5;
cube[6] = v6;
cube[7] = v7;
for (i = 0; i < 8; i++)
{
noiseCube[i] = DCManager.radius - (cube[i] + position).magnitude;
if (noiseCube[i] <= treshold)
{
flagIndex |= 1 << i; // flagIndex = flagIndex | 1<<i
}
//if(cube[i])
}
if (flagIndex == 0 || flagIndex == 255)
{
continue;
}
// prepara gli spigoli e ordinali in un dizionario
edgeList.Add(new CellEdge(v0, v1, noiseCube[0], noiseCube[1], position, treshold));
edgeList.Add(new CellEdge(v2, v3, noiseCube[2], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v4, v5, noiseCube[4], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v6, v7, noiseCube[6], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v1, v5, noiseCube[1], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v0, v4, noiseCube[0], noiseCube[4], position, treshold));
edgeList.Add(new CellEdge(v2, v6, noiseCube[2], noiseCube[6], position, treshold));
edgeList.Add(new CellEdge(v3, v7, noiseCube[3], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v0, v3, noiseCube[0], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v1, v2, noiseCube[1], noiseCube[2], position, treshold));
edgeList.Add(new CellEdge(v4, v7, noiseCube[4], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v5, v6, noiseCube[5], noiseCube[6], position, treshold));
// per ogni cubo trova quanti spigoli hanno intersezioni
numEdgesWithIntersections = 0;
centerPoint = new Vector3();
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryYPlusNormalPatch);
numEdgesWithIntersections++;
centerPoint += ce.intersectionPoint;
}
}
if (numEdgesWithIntersections == 0 || numEdgesWithIntersections == 8)
{
continue;
}
centerPoint = centerPoint / numEdgesWithIntersections;
// ora che sappiamo quanti spigoli hanno intersezioni calcola il punto medio tra loro e settalo come punto centrale della cella
// dual contour - per infighettarlo qua dovresti applicare la QEF, invece del punto medio tra gli spigoli che hanno intersezioni
int k = 0;
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryYPlusNormalPatch);
c.cells[k] = centerPoint;
}
k++;
if (k > 3)
{
k = 0;
}
}
}
}
}
/////////////////
// spigoli esterni Z+
for (x = 0; x < subdivisions; x++)
{
for (y = 0; y < subdivisions; y++)
{
for (z = subdivisions; z < subdivisions + 1; z++)
{
edgeList.Clear();
cube = new Vector3[8];
noiseCube = new float[8];
edgeVertex = new Vector3[12];
numEdgesWithIntersections = 0;
flagIndex = 0;
Vector3 v0 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v1 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v2 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v3 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v4 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
Vector3 v5 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v6 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v7 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
cube[0] = v0;
cube[1] = v1;
cube[2] = v2;
cube[3] = v3;
cube[4] = v4;
cube[5] = v5;
cube[6] = v6;
cube[7] = v7;
for (i = 0; i < 8; i++)
{
noiseCube[i] = DCManager.radius - (cube[i] + position).magnitude;
if (noiseCube[i] <= treshold)
{
flagIndex |= 1 << i; // flagIndex = flagIndex | 1<<i
}
//if(cube[i])
}
if (flagIndex == 0 || flagIndex == 255)
{
continue;
}
// prepara gli spigoli e ordinali in un dizionario
edgeList.Add(new CellEdge(v0, v1, noiseCube[0], noiseCube[1], position, treshold));
edgeList.Add(new CellEdge(v2, v3, noiseCube[2], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v4, v5, noiseCube[4], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v6, v7, noiseCube[6], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v1, v5, noiseCube[1], noiseCube[5], position, treshold));
edgeList.Add(new CellEdge(v0, v4, noiseCube[0], noiseCube[4], position, treshold));
edgeList.Add(new CellEdge(v2, v6, noiseCube[2], noiseCube[6], position, treshold));
edgeList.Add(new CellEdge(v3, v7, noiseCube[3], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v0, v3, noiseCube[0], noiseCube[3], position, treshold));
edgeList.Add(new CellEdge(v1, v2, noiseCube[1], noiseCube[2], position, treshold));
edgeList.Add(new CellEdge(v4, v7, noiseCube[4], noiseCube[7], position, treshold));
edgeList.Add(new CellEdge(v5, v6, noiseCube[5], noiseCube[6], position, treshold));
// per ogni cubo trova quanti spigoli hanno intersezioni
numEdgesWithIntersections = 0;
centerPoint = new Vector3();
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryZPlusNormalPatch);
numEdgesWithIntersections++;
centerPoint += ce.intersectionPoint;
}
}
if (numEdgesWithIntersections == 0 || numEdgesWithIntersections == 8)
{
continue;
}
centerPoint = centerPoint / numEdgesWithIntersections;
// ora che sappiamo quanti spigoli hanno intersezioni calcola il punto medio tra loro e settalo come punto centrale della cella
// dual contour - per infighettarlo qua dovresti applicare la QEF, invece del punto medio tra gli spigoli che hanno intersezioni
int k = 0;
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryZPlusNormalPatch);
c.cells[k] = centerPoint;
}
k++;
if (k > 3)
{
k = 0;
}
}
}
}
}
/////////////////
mapData.edgeDictionary = edgeDictionary;
mapData.edgeDictionaryXPlusNormalPatch = edgeDictionaryXPlusNormalPatch;
//mapData.edgeDictionaryYPlusNormalPatch = edgeDictionaryYPlusNormalPatch;
//mapData.edgeDictionaryZPlusNormalPatch = edgeDictionaryZPlusNormalPatch;
return(mapData);
}
public MapData GenerateTerrainData(float size, int subdivisions, Vector3 position, CustomImprovedNoise noise,
Dictionary <string, CellEdge> edgeDictionary,
Dictionary <string, CellEdge> edgeDictionaryOrphans
)
{
this.position = position;
this.subdivisions = subdivisions;
float increment = size / subdivisions;
int flagIndex = 0;
//float treshold = 0.4f;
float treshold = DCManager.radius * 0.55f;
Vector3 centerPoint;
int i, x, y, z;
Vector3[] edgeVertex;
List <CellEdge> edgeList = new List <CellEdge>();
int numEdgesWithIntersections = 0;
MapData mapData = new MapData();
Vector3[] cube;
float[] noiseCube;
// trova gli spigoli che hanno intersezioni e dove: quando li trovi salvali in edgeDictionary
// con nome [punto fuori + "|"+ punto dentro], valore la cellEdge(che contiene i 4 centerPoints)
for (x = 0; x < subdivisions; x++)
{
for (y = 0; y < subdivisions; y++)
{
for (z = 0; z < subdivisions; z++)
{
edgeList.Clear();
cube = new Vector3[8];
noiseCube = new float[8];
edgeVertex = new Vector3[12];
numEdgesWithIntersections = 0;
flagIndex = 0;
Vector3 v0 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v1 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v2 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment + increment);
Vector3 v3 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment, -size / 2 + z * increment);
Vector3 v4 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
Vector3 v5 = new Vector3(-size / 2 + x * increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v6 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment + increment);
Vector3 v7 = new Vector3(-size / 2 + x * increment + increment, -size / 2 + y * increment + increment, -size / 2 + z * increment);
cube[0] = v0;
cube[1] = v1;
cube[2] = v2;
cube[3] = v3;
cube[4] = v4;
cube[5] = v5;
cube[6] = v6;
cube[7] = v7;
for (i = 0; i < 8; i++)
{
noiseCube[i] = DCManager.radius - (cube[i] + position).magnitude;
if (noiseCube[i] <= treshold)
{
flagIndex |= 1 << i;
}
}
if (flagIndex == 0 || flagIndex == 255)
{
continue;
}
// prepara gli spigoli e ordinali in un dizionario
edgeList.Add(new CellEdge(v0, v1, noiseCube[0], noiseCube[1], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v2, v3, noiseCube[2], noiseCube[3], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v4, v5, noiseCube[4], noiseCube[5], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v6, v7, noiseCube[6], noiseCube[7], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v1, v5, noiseCube[1], noiseCube[5], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v0, v4, noiseCube[0], noiseCube[4], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v2, v6, noiseCube[2], noiseCube[6], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v3, v7, noiseCube[3], noiseCube[7], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v0, v3, noiseCube[0], noiseCube[3], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v1, v2, noiseCube[1], noiseCube[2], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v4, v7, noiseCube[4], noiseCube[7], position, treshold)
{
px = x, py = y, pz = z
});
edgeList.Add(new CellEdge(v5, v6, noiseCube[5], noiseCube[6], position, treshold)
{
px = x, py = y, pz = z
});
// per ogni cubo trova quanti spigoli hanno intersezioni
numEdgesWithIntersections = 0;
centerPoint = new Vector3();
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryOrphans);
numEdgesWithIntersections++;
centerPoint += ce.intersectionPoint;
}
}
//salta le celle tutte piene e quelle tutte vuote
if (numEdgesWithIntersections == 0 || numEdgesWithIntersections == 8)
{
continue;
}
// ora che sappiamo quanti spigoli hanno intersezioni calcola il punto medio tra loro e settalo come punto centrale della cella
// dual contour - per infighettarlo qua dovresti applicare la QEF, invece del punto medio tra gli spigoli che hanno intersezioni
centerPoint = centerPoint / numEdgesWithIntersections;
int k = 0;
foreach (CellEdge ce in edgeList)
{
if (ce.hasIntersection)
{
CellEdge c = getOrAdd(ce, edgeDictionaryOrphans);
//if (numEdgesWithIntersections == 4) {
// c = getOrAdd(ce, edgeDictionary);
//if (c.cells[k] != Vector3.zero) Debug.Log("ERROR"); //TODO: check why I would possibly overwrite a preesisting(?) [k] value
c.cells[k] = centerPoint; //questa cosa della k, vista dopo anni, sembra funzionare per caso...
}
k++;
if (k > 3)
{
k = 0;
}
}
//Debug.Log("edgeDictionaryOrphans:" + edgeDictionaryOrphans.Count());
}
}
} // fine del mega ciclo
List <String> edgesKeysToMove = new List <String>();//edgeDictionaryOrphans.Keys.Except(keysToInclude).ToList();
foreach (CellEdge ce in edgeDictionaryOrphans.Values)
{
if (ce.cells.Count(v => v != Vector3.zero) == 4)
{
edgesKeysToMove.Add(ce.name);
}
}
foreach (String key in edgesKeysToMove)
{
CellEdge ce = edgeDictionaryOrphans[key];
getOrAdd(ce, edgeDictionary);
edgeDictionaryOrphans.Remove(ce.name);
}
mapData.edgeDictionary = edgeDictionary;
mapData.edgeDictionaryOrphans = edgeDictionaryOrphans;
return(mapData);
}
