如何优化我的 2d java 游戏渲染？

Question

My problem is, I have a game with a random generated map and it has only 30-40 fps because of the number of blocks.(You can imagine my game like a 2d minecraft).

First I search for the first tile what is in screen. Then start a loop render tile next tile... until I reach the last tile what you can see.

(I don't use any of the Java classes like graphics/graphics2d I use my own code what is an int[] with the rows of teh screen in it and when I render a tile I change the int[x+y*width] position of the screen to the correct pixel of the block)

I think logically this is the best way to render my map and i don't understend why is the low fps. I am wrong or I need to search for some other problem in my code? Or there is any better rendering method?

If I skip the rendering of the world, there is stabile 120 fps what is capped there. What can be the problem?

Answer 1

I know you dont use the Gaphics functions and choose to manipulate a pixel-array instead.

Try to change your game to use the Graphics object since there is no (easy and efficient) way around it. If you still choose not to do so, try to add

System.setProperty("sun.java2d.opengl", "true");

at the very begining of your code just after

public static void main(String[] args) {

I tried to do it the same way as you back when i first made simple games but you later come to realize that the built-in Graphics functions are vastly superior in performance and ease of use.

EDIT:

A short explanaition on how a basic game might use the Graphics object:

Suppose you created a JFrame. If you then add a class that extends from Canvas and add that to it. If you want to use a menu, you might even create a JPanel first and add the Canvas into the Jpanel so you can hide it more easily.

Here you have an example how we create a usable canvas:

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;

import javax.swing.JFrame;

public class Game extends Canvas implements Runnable{

  private static final long serialVersionUID = 1L;

  public static final int WIDTH = 1920;
  public static final int HEIGHT = WIDTH * 9 / 16; 
  public static final String TITLE = "YOUR GAMES NAME";
  public static final int TICKSPERS = 120;
  public static final boolean ISFRAMECAPPED = false;


  public static JFrame frame;

  private Thread thread;
  private boolean running = false;

  public int frames;
  public int lastFrames;
  public int ticks;

  public Game(){
      Dimension size = new Dimension(WIDTH, HEIGHT);
      setPreferredSize(size);
      setMaximumSize(size);
      setMinimumSize(size);
  }

  public void render(){
      frames++;
      BufferStrategy bs = getBufferStrategy();
      if (bs == null){
          createBufferStrategy(2);
          return;
      }
      Graphics g = bs.getDrawGraphics();
      g.setColor(new Color(79,194,232));
      g.fillRect(0, 0, getWidth(), getHeight());
      //Call your render funtions from here

      g.setColor(Color.BLACK);
      g.fillRect(120,70,35,90);

      g.dispose();
      bs.show();
  }

  public void tick(){
  }

  public synchronized void start(){
      if(running) return;
      running = true;
      thread = new Thread(this, "Thread");
      thread.start();
  }

  public synchronized void stop(){
      if(!running) return;
      running = false;
      try {
          System.exit(1);
          frame.dispose();
          thread.join();
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }

  public void init(){

  }

  public void run() {
      init();
      //Tick counter variable
      long lastTime = System.nanoTime();
      //Nanoseconds per Tick
      double nsPerTick = 1000000000D/TICKSPERS;
      frames = 0;
      ticks = 0;
      long fpsTimer = System.currentTimeMillis();
      double delta = 0;
      boolean shouldRender;
      while(running){
          shouldRender = !ISFRAMECAPPED;
          long now = System.nanoTime();
          delta += (now - lastTime) / nsPerTick;
          lastTime = now;
          //if it should tick it does this
          while(delta >= 1 ){
              ticks++;
              tick();
              delta -= 1;
              shouldRender = true;
          }
          if (shouldRender){
          render();
          }
          if (fpsTimer < System.currentTimeMillis() - 1000){
              System.out.println(ticks +" ticks, "+ frames+ " frames");
              ticks = 0;
              lastFrames = frames;
              frames = 0;
              fpsTimer = System.currentTimeMillis();
          }
      }
  }

  public static void main(String[] args){
      Game game = new Game();
      frame = new JFrame(TITLE);
      frame.add(game);
      frame.pack();
      frame.setResizable(false);
      frame.setLocationRelativeTo(null);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
      game.start();
  }

}

This class can be your base. Its tick method is called 120 times a second and its render method can render stuff onto the screen. If you are not familiar with the functions of the Graphics Object i suggest reading a little about them.

You can't reach the Graphics object from the outside. You need to call the render functions from inside the games render function before the Graphics object gets disposed. Try to seperate your game logic from the render functions.

Answer 2

I use a slightly different architecture than what's stated above. I actually create a separate Renderer object which is basically a deferred renderer.

It's structured like this

public class App {
    JFrame window;
    Renderer renderer;
    Engine engine; //implementation is a nested class within App
  
    Dimension window_dimension; //stored for later use

    public App() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                
                window = new JFrame("MyGame");
                boolean full_screen = true;
                window_dimension = initializeWindow(window, full_screen);
                
                renderer = new Renderer(window_dimension);
                window.add(renderer);

                engine = new Engine(renderer);
                engine.start();                
            }
        });
    }
}

Renderer.java :

import java.awt.*;

import java.util.concurrent.CopyOnWriteArrayList;

public class Renderer extends JPanel {
    Dimension dim;
    private CopyOnWriteArrayList<Drawable> drawables = new CopyOnWriteArrayList<Drawable>();

    Renderer(Dimension dim) {
        this.dim = dim;
    }
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

        g2d.clearRect(0, 0, getWidth(), getHeight());
        

        for (Drawable drawable : drawables) {
            drawable.paint(g2d);
        }
        
        g2d.dispose();
        
        drawables.clear();
    }

   public synchronized void render() {
       repaint();
   }

    public synchronized void submit(Drawable drawable) {
        drawables.add(drawable);
    }

    public synchronized void submitBackground(Drawable drawable) {
        drawables.add(0,drawable);
    }
}

Drawable.java :

import java.awt.*;
abstract class Drawable {

    protected Stroke stroke;
    protected Color color, stroke_color;
    public Dimension size;
   
    public float sub_pixel_x;
    public float sub_pixel_y;

    public Drawable(Color color) {

        setColor(color);
        setStrokeColor(new Color(0));

        sub_pixel_x = 0.0f;
        sub_pixel_y = 0.0f;
        size = new Dimension(10, 10);

    }

    public void setStroke(float width) {
        stroke = new BasicStroke(width);
    }
   
    public void noStroke() {
        stroke = null;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public void setStrokeColor(Color color) {
        this.stroke_color = color;
    }

    public void setLocation(float x, float y) {
        sub_pixel_x = x;
        sub_pixel_y = y;
    }

    
    protected abstract void paint(Graphics2D g2d);
    
}

AbstractEngine.java :

import java.awt.*;

abstract class AbstractEngine implements Runnable  {
    Renderer renderer;
    Dimension dimension;
    boolean running;

    Thread thread;
    public AbstractEngine(Renderer renderer) {
        this.renderer = renderer;
        dimension = renderer.dim;
    }

 
    public void start() {
        if (running) return;
        running = true;
        thread = new Thread(this, "Tread");
        thread.start();
    }

    public void stop() {
        if(!running) return;
        running = false;
        try {
            System.exit(1);
            thread.join();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public abstract void handleInput();
    public abstract void update();
    public abstract void render();

    @Override 
    public void run() {
        final int UPS = 120;
        final int FPS = 60;

        
        long initialTime = System.nanoTime();
        final double timeU = 1000000000 / UPS;
        final double timeF = 1000000000 / FPS;
        double deltaU = 0, deltaF = 0;
        int frames = 0, ticks = 0;
        long timer = System.currentTimeMillis();

        while (running) {
            long currentTime = System.nanoTime();
            deltaU += (currentTime - initialTime) / timeU;
            deltaF += (currentTime - initialTime) / timeF;
            initialTime = currentTime;

            if (deltaU >= 1) {
                handleInput();
                update();
                ticks++;
                deltaU--;
            }

            if (deltaF >= 1) {
                render();
                renderer.render();
                frames++;
                deltaF--;
            }

            if (System.currentTimeMillis() - timer > 1000) {
                frames = 0;
                ticks = 0;
                timer += 1000;
            }
        }
    }
}

Input is handled in the extended Engine class. I have a MouseState object that holds mouse positions and button state. I then create a MouseAdapter that updates the date in MouseState and attach it to the renderer. It's a bit weird, I know, but works nicely.