Richtige Verwendung von scene2d's Stage in einem Spiel mit einer riesigen Welt

Question

Wenn die gesamte "Spielwelt" tausendmal breiter ist als ein Ansichtsfenster, und wenn ich scene2d verwenden möchte, um Spielobjekte wie Actors zu verwalten, sollte ich Stage erstellen Objekt so breit wie die ganze Welt, oder sollte die Stage ein Bereich um das aktuelle Ansichtsfenster sein, aber nicht die ganze Welt?
Mit anderen Worten, verbraucht ein Stage mit größerer Breite und Höhe mehr Speicher selbst, auch wenn ich Objekte nur auf einem kleinen Bereich im Darstellungsbereich rendere?

Answer 1

Ich denke, Sie haben missverstanden, was genau ein Stage ist. Eine Bühne hat nicht wirklich eine Größe. Sie geben keine Breite oder Höhe an oder die Stage, Sie geben nur die Breite und Höhe des Ansichtsfensters an. Das Ansichtsfenster ist wie ein Fenster, das nur einen Teil deiner Welt, aka Szene, zeigt. A Stage ist ein 2D-Szenengraph und "wächst" mit Ihrer Actors. Je mehr Schauspieler Sie haben, desto größer (speichermäßig) ist Ihre Bühne, aber es kommt nicht darauf an, wie weit Ihre Schauspieler tatsächlich verteilt sind. Wenn sie sehr weit verbreitet sind und Sie nur einen sehr kleinen Teil Ihrer gesamten Stage anzeigen, wird dies sehr effizient gehandhabt, da ein Szenengraph diesen riesigen Raum unterteilt, um sehr schnell entscheiden zu können, ob ein bestimmter Actor ignoriert werden soll. oder zeichne es auf dem Bildschirm.

Das bedeutet eine Stage ist eigentlich genau das, was Sie für diese Art von Situation brauchen, und Sie sollten wahrscheinlich keine Probleme haben, FPS und Speicher. Aber natürlich, wenn Ihr Stage 1000 mal die Größe Ihres Ansichtsfensters ist und Sie selbst wissen, dass bestimmte Akteure nicht bald angezeigt werden, dann könnte es sinnvoll sein, sie noch nicht zur Bühne hinzuzufügen.

Answer 2

Eine Bühne ist nur ein Wurzelknoten, der alle Akteure enthält. Es ist Aufgabe, Methoden für seine Kinder aufzurufen (wie zeichnen und handeln); somit haben nur die Anzahl und die Komplexität des Schauspielers einen Einfluss auf die Speicher- und Bildrate.

Für Ihre Situation ist eine Culling-Methode sicherlich erforderlich. Am einfachsten wäre es, zu überprüfen, ob sich ein Darsteller im Darstellungsbereich befindet und ihn nicht überspringt. Erstellen Sie einen benutzerdefinierten Schauspieler und fügen Sie diesen Code: source

 public void draw (SpriteBatch batch, float parentAlpha) { 
      // if this actor is not within the view of the camera we don't draw it. 
      if (isCulled()) return; 

      // otherwise we draw via the super class method 
      super.draw(batch, parentAlpha); 
     }  




     Rectangle actorRect = new Rectangle(); 
     Rectangle camRect = new Rectangle(); 
     boolean visible; 

     private boolean isCulled() { 

      // we start by setting the stage coordinates to this 
      // actors coordinates which are relative to its parent 
      // Group. 
      float stageX = getX(); 
      float stageY = getY(); 

      // now we go up the hierarchy and add all the parents' 
      // coordinates to this actors coordinates. Note that 
      // this assumes that neither this actor nor any of its 
      // parents are rotated or scaled! 
      Actor parent = this.getParent(); 
      while (parent != null) { 
       stageX += parent.getX(); 
       stageY += parent.getY(); 
       parent = parent.getParent(); 
      } 

      // now we check if the rectangle of this actor in screen 
      // coordinates is in the rectangle spanned by the camera's 
      // view. This assumes that the camera has no zoom and is 
      // not rotated! 
      actorRect.set(stageX, stageY, getWidth(), getHeight()); 
      camRect.set(camera.position.x - camera.viewportWidth/2.0f, 
        camera.position.y - camera.viewportHeight/2.0f, 
        camera.viewportWidth, camera.viewportHeight); 
      visible = (camRect.overlaps(actorRect)); 
      return !visible; 
     } 

Wenn Sie die Performance verbessern müssen noch weiter Sie wechseln können manuell entscheiden, was sichtbar ist und was nicht (ex, wenn die Kamera bewegt). Dies wäre schneller, weil all diese Culling-Berechnungen für jeden Frame für jeden Schauspieler ausgeführt werden. Obwohl es viel schneller ist, etwas Mathe zu machen, anstatt zu zeichnen, würde eine große Anzahl von Schauspielern eine große Menge unerwünschter Anrufe geben.