Question

我理解这个概念但是我在实现2D细分背后的循环逻辑时遇到了麻烦。我有一个二维数组代表一个带有角落种子的网格。我相信我需要3个循环。 1循环细分迭代次数。行中每列的第二个，每行第三个。

这就是我所拥有的。它显示了左上角的方形细分的结果。这就是行和列只循环一次的原因。如果我得到基本的逻辑，剩下的应该是蛋糕。但是循环在第三次迭代时不起作用。我很确定循环需要更复杂。

迭代是手动设置的变量。

       // iterate though subdivision levels
       for(i = 1; i <= iterations; i++) {                   // iteration

            // iterate through each row
            for(row = 1; row <= 1; row += size / i ) {      // row

                // iterate through each column and subdivide
                for(col = 1; col <= 1; col += size / i) {   // column

                    //*** ONLY SHOWING THE FIRST SUBDIVIDE OF EACH ITERATION ***//

                    // Math.pow(2, iterations) / 2 / i = 1
                    // i = 1, iteration = 1
                    heightmap[0][1] = (heightmap[0][0] + heightmap[0][2]) / 2;

                    // Math.pow(2, iterations) / 2 / i = 2
                    // i = 1, iterations = 2
                    heightmap[0][2] = (heightmap[0][0] + heightmap[0][4]) / 2;

                    // Math.pow(2, iterations) / 2 / i = 4
                    // i = 1, iterations = 3
                    heightmap[0][4] = (heightmap[0][0] + heightmap[0][8]) / 2;

                    // if iterations == 1, i != 2

                    // Math.pow(2, iterations) / 2 / i = 1
                    // i = 2, iterations = 2
                    heightmap[0][1] = (heightmap[0][0] + heightmap[0][2]) / 2;

                    // Math.pow(2, iterations) / 2 / i = 2
                    // i = 2, iterations = 3
                    heightmap[0][2] = (heightmap[0][0] + heightmap[0][4]) / 2;

                    // if iterations == 1 or 2, i != 3

                    // Math.pow(2, iterations) / 2 / i = 4/3 != 1
                    // i = 3, iterations = 3
                    heightmap[0][1] = (heightmap[0][0] + heightmap[0][2]) / 2;
                }
            }
        }

如果这有助于我用于1D细分。

// increase the number of segments
for(var i = 1; i < size; i *= 2){

    // iterate through each segment calculating the center point
    for(var j = (size / i) / 2; j < size; j += size / i){
        points[j] = ((points[j - (size / i) / 2] + points[j + (size / i) / 2]) / 2);
    }

}

Answer 1

当时细分一个方向会更容易：

var points = [[ 0,-1,-1,-1, 1],
              [-1,-1,-1,-1,-1],
              [-1,-1,-1,-1,-1],
              [-1,-1,-1,-1,-1],
              [ 2,-1,-1,-1, 0]];
var size = 4;

for (var iteration = 1; iteration < size; iteration *= 2) {
    var step = size / iteration;

    // * . * . *
    // x . x . x
    // * . * . *
    for (var row = step / 2; row < size; row += step) {
        for (var col = 0; col <= size; col += step) {
            points[row][col] = ((points[row - step / 2][col] + points[row + step / 2][col]) / 2);
        }
    }

    // * x * x *
    // * x * x *
    // * x * x *
    for (var row = 0; row <= size; row += step / 2) {
        for (var col = step / 2; col < size; col += step) {
            points[row][col] = ((points[row][col - step / 2] + points[row][col + step / 2]) / 2);
        }
    }
}

结果是：

[[ 0,   0.25,   0.5,   0.75,   1    ],
 [ 0.5, 0.5625, 0.625, 0.6875, 0.75 ],
 [ 1,   0.875,  0.75,  0.625,  0.5  ],
 [ 1.5, 1.1875, 0.875, 0.5625, 0.25 ],
 [ 2,   1.5,    1,     0.5,    0    ]]

试图在2D中点细分中计算循环的逻辑

1 个答案: