Wie platziere ich Objekte, die sich nicht überlappen, zufällig?

Ich erstelle eine zufällig generierte Umgebung für ein Spiel, das ich entwickle. Ich benutze OpenGLund codiere in Java.

Ich versuche, zufällig Bäume in meiner Welt zu platzieren (um einen Wald zu erstellen), aber ich möchte nicht, dass sich die Modelle überlappen (was passiert, wenn zwei Bäume zu nahe beieinander stehen). Hier ist ein Bild von dem, wovon ich spreche:

Ich kann bei Bedarf mehr Code bereitstellen, aber hier sind die wesentlichen Ausschnitte. Ich lagere meine Objekte in einem ArrayListmit List<Entity> entities = new ArrayList<Entity>();. Ich füge dieser Liste dann Folgendes hinzu:

Random random = new Random();
for (int i = 0; i < 500; i++) {
    entities.add(new Entity(tree, new Vector3f(random.nextFloat() * 800 - 400, 
    0, random.nextFloat() * -600), 0, random.nextFloat() * 360, 0, 3, 3, 3);
}

Dabei Entityfolgt jeder der folgenden Syntax:

new Entity(modelName, positionVector(x, y, z), rotX, rotY, rotZ, scaleX, scaleY, scaleZ);

rotXist die Drehung entlang der x-Achse und scaleXist die Skala in x-Richtung usw.

Sie können sehen , dass ich diese Bäume zufällig bin Platzierung random.nextFloat()für die xund zPositionen, und begrenzen den Bereich , so dass die Bäume in der gewünschten Position angezeigt werden. Ich möchte diese Positionen jedoch irgendwie steuern, sodass beim Versuch, einen Baum zu nahe an einem zuvor platzierten Baum zu platzieren, eine neue zufällige Position neu berechnet wird. Ich dachte, dass jeder Baum Entityein anderes Feld haben könnte, wie zum Beispiel treeTrunkGirth, und wenn ein Baum in der Entfernung zwischen dem Standort eines anderen Baums und treeTrunkGirthseinem Platz platziert wird, berechnet er eine neue Position neu. Gibt es eine Möglichkeit, dies zu erreichen?

Gerne füge ich bei Bedarf weitere Codefragmente und Details hinzu.

Mit einer Poisson-Disk-Sampling- Verteilung können Sie zufällige Punkte in einem Mindestabstand auswählen. Ihre Situation ähnelt dieser Frage , aber da Ihre Bäume keine idealisierten Punkte sind, müssen Sie die Entfernungsprüfung wie folgt ändern: Die Entfernung zwischen einem potenziellen neuen Baum und einem vorhandenen Baum muss kleiner sein als die Summe ihrer Radien .

Der Bridson-Algorithmus kann das Problem in O (n) effizient lösen, aber es kann etwas umständlich sein, es für variable Entfernungen zu optimieren. Wenn Ihre Parameter niedrig sind und / oder Sie Ihr Gelände vorberechnen, kann Ihnen eine Brute-Force-Lösung genauso gut helfen. Hier ist ein Beispielcode, der das Problem durch Brute erzwingt, indem jede potenzielle neue Baumplatzierung mit allen zuvor platzierten Bäumen verglichen wird:

public static class SimpleTree{
    float x;
    float z;
    float r;

    public SimpleTree(Random rng, float xMax, float zMax, float rMin, float rMax){
        x = rng.nextFloat() * xMax;
        z = rng.nextFloat() * zMax;
        r = rng.nextFloat() * (rMax-rMin) + rMin;
    }
}

private static ArrayList<SimpleTree> buildTreeList(float xMax, float zMax, 
        float rMin, float rMax, int maxAttempts, Random rng) {
    ArrayList<SimpleTree> result = new ArrayList<>();

    SimpleTree currentTree = new SimpleTree(rng, xMax, zMax, rMin, rMax);
    result.add(currentTree);

    boolean done = false;
    while(!done){
        int attemptCount = 0;
        boolean placedTree = false;
        Point nextPoint = new Point();
        SimpleTree nextTree = null;
        while(attemptCount < maxAttempts && !placedTree){
            attemptCount++;
            nextTree = new SimpleTree(rng, xMax, zMax, rMin, rMax);
            if(!tooClose(nextTree, result)){
                placedTree = true;
            }
        }
        if(placedTree){
            result.add(nextTree);
        }
        else{
            done = true;
        }
    }

    return result;
}

private static boolean tooClose(SimpleTree tree, ArrayList<SimpleTree> treeList) {
    for(SimpleTree otherTree : treeList) {
        float xDiff = tree.x - otherTree.x;
        float zDiff = tree.z - otherTree.z;

        float dist = (float)Math.sqrt((xDiff * xDiff) + (zDiff * zDiff));
        if(dist < tree.r + otherTree.r){
            return true;
        }
    }        
    return false;
}

Mit folgenden Parametern:

 maxAttempts = 500;
 width = 300;
 height = 200;
 minSize = 2;
 maxSize = 15;

Ich konnte in weniger als einer Sekunde zwischen 400 und 450 Bäume zufällig platzieren und rendern. Hier ist ein Beispiel: