Effectively, my query is fairly easy to grasp, I am making an attempt to create a grid of chunks however on every step, I need to double the gap of a bit.
Then, that is the code I’ve:
utilizing System.Collections.Generic;
utilizing UnityEngine;
[ExecuteInEditMode]
public class DrawLoDTest : MonoBehaviour
{
non-public Listing<Vector3> initialChunks;
public int chunkSize = 16;
public int lodLevels = 2;
public int width = 16;
public int peak = 16;
non-public Coloration[] colorList;
// Begin is known as earlier than the primary body replace
non-public void Begin()
{
}
// Replace is known as as soon as per body
non-public void Replace()
{
}
non-public void Init()
{
if (initialChunks != null && initialChunks.Depend > 0)
return;
colorList = new[] { Coloration.blue, Coloration.inexperienced, Coloration.yellow, Coloration.cyan, Coloration.magenta, Coloration.gray };
Debug.Log("Init take a look at!");
initialChunks = new Listing<Vector3>(16 * 16);
for (var i = 0; i < width * peak; i++)
{
var x = i % width;
var y = i / width;
initialChunks.Add(new Vector3(x * chunkSize - width * chunkSize / 2, 0, y * chunkSize - peak * chunkSize / 2));
}
//Debug.Log(string.Be part of(Atmosphere.NewLine, initialChunks.Choose(v => v.ToString())));
}
non-public void OnDrawGizmos()
{
Init();
Gizmos.coloration = Coloration.pink;
foreach (var chunk in initialChunks)
{
Gizmos.DrawWireCube(chunk, Vector3.one * chunkSize);
}
var ww = 0;
var ww2 = 0;
var sum = 0;
var halfChunkSize = chunkSize / 2;
var halfWidth = width * halfChunkSize;
var halfHeight = peak * halfChunkSize;
for (var i = 1; i <= lodLevels; i++)
{
if (ww > 0)
++ww2;
var pow = (int)Mathf.Pow(2, i);
var w = width / pow;
var h = peak / pow;
Gizmos.coloration = colorList[i - 1];
var oddSum = ww * chunkSize * pow;
for (var x = -1 - ww2; x <= w + ww2; x++)
{
for (var n = 0; n <= 1; n++)
{
var signal = n == 0 ? -1 : 1;
var chunk = new Vector3(
halfWidth - x * chunkSize * pow - halfChunkSize,
0,
halfHeight * signal - halfChunkSize - chunkSize * 2 * signal + oddSum * signal + sum * signal);
chunk.x -= pow * halfChunkSize;
for (var j = i + 1; j >= i; j--)
{
chunk.z += chunkSize * (int)Mathf.Pow(2, j) / 2 * signal;
}
Gizmos.DrawWireCube(chunk, Vector3.one * chunkSize * pow);
}
}
// TODO
if ((w + ww2 * 2 + 2) / 2 % 2 != 0)
{
Debug.Log($"[{i}, {ww}, {ww2}] W: {w} + {ww2} * 2 = {w + ww2 * 2} + 2 = {w + ww2 * 2 + 2} / 2 = {(w + ww2 * 2 + 2) / 2}");
if (ww == 0)
{
--i;
++ww;
}
else
{
ww = 0;
sum += oddSum;
}
}
else
{
if (ww2 > 0)
ww2 = 0;
}
}
}
}
Slightly little bit of rationalization:
- First, I load a 16×16 chunk grid (
initialChunks
). - Then, I begin a loop foreach lod stage (I am testing it for six ranges).
- Then, foreach axis I iterate its place.
- Then, in a nested loop foreach axis I give an indication (a loop for 0 to 1, that converts into -1 and 1 for the signal).
- Then, and that is the extra advanced factor, if the next row/column has an odd variety of components then I attempt to match the present row/column by doubling it, in that method non of the next nook will probably be half of the earlier one.
I’ve two fundamental issues:
For some purpose, sum
and oddSum
variables has the improper enter.
At sure ranges, (for i >= 5
) the logic is damaged.