[prev in list] [next in list] [prev in thread] [next in thread] 

List:       openjdk-openjfx-dev
Subject:    Transparent stages and AnimationTimer on Windows
From:       John Hendrikx <hjohn () xs4all ! nl>
Date:       2021-09-28 22:46:43
Message-ID: 5948baf5-312d-c50b-9467-2ab1e5532047 () xs4all ! nl
[Download RAW message or body]

I'm seeing some really weird issues with Transparent Stages on Windows 
when their framerate (both stability and speed) is compared with normal 
decorated/undecorated stages.

The transparent stages seem to obey different rules when it comes to 
timely firing AnimationTimers.

Where a decorated stage will show an almost exact 60 Hz in all 
circumstances (usually in a pattern of 24 frames of ~15ms then a double 
frame of ~30ms averaging out to 1/60th of a second per frame) the 
transparent stages act completely different.  Increasing the 
javafx.animation.pulse on a decorated stage to say 240 will reduce this 
variance even further (min/max will be between 16 and 18 ms) while 
keeping an exact 60 Hz.

However, on a transparent stage this all goes out the window:

Running a test with javafx.animation.pulse left unchanged, it reaches an 
unsteady 56/57 Hz with the variance being incredibly high and random (5 
- 40 ms)... while FOCUSED.  Unfocusing the stage and this becomes a more 
steady 62.5 Hz and the variance reduces to 8 - 24 ms. Refocusing the 
stage immediately sees variance spiking again and framerate dropping to 
an unsteady 56/57 Hz.

The same test with javafx.animation.pulse set to 240 on a transparent 
stage shows some odd things as well.  While focused the stage retains a 
similar behaviour (unsteady 56/57 Hz with a 5-40 ms variance).  When 
unfocused it starts running at 72-78 Hz with about an 8-24 ms variance 
(same as before but with a higher frame rate).

Setting javafx.animation.pulse to 24 for a transparent stage locks the 
framerate to an exact 24 Hz with almost no variance.  Focused/unfocused 
suddenly makes no difference any more. For decorated/undecorated stages 
this does not change the framerate (it remains rock solid at 60 Hz) but 
the variances become much larger (but show a steady repeated pattern).

So in summary:

1) Decorated/undecorated stages perform very stable, variance can be 
reduced by increasing javafx.animation.pulse -- this property seems to 
have the effect of making the animation timings more accurate (reduces 
variance) while retaining an exact 60 Hz. The variance pattern is very 
consistent and predictable.

2) Transparent stages perform much more erratic, and are extra erratic 
when they have focus.  They never reach an exact 60 Hz (measured over 
300 frames) but either go several frames under (57.5 Hz when focused) or 
over (62.5 Hz when not focused). Their variance has no pattern to it and 
seems random.

3) javafx.animation.pulse for Transparent stages seems to control the 
maximum frame rate (setting it to 24 for example will limit the fps to 
almost exactly 24 Hz with almost no variance).

Below is the code I used to test this.

--John

public class FrameRateTest extends Application {
   private static int SIZE = 300;

   @Override
   public void start(Stage stage) {
       System.out.println("javafx.runtime.version: " + 
System.getProperties().get("javafx.runtime.version"));

       Label fpsLabel = new Label();

       fpsLabel.setTextFill(Color.ALICEBLUE);
       Canvas canvas = new Canvas(SIZE, 100);

       GraphicsContext g2d = canvas.getGraphicsContext2D();
       g2d.setStroke(Color.WHITE);

       StackPane fpsPane = new StackPane(fpsLabel, canvas);

       AnimationTimer frameRateMeter = new AnimationTimer() {
         private final long[] frameTimes = new long[SIZE];
         private final long[] frameDeltas = new long[SIZE];

         private int frameTimeIndex = 0;
         private int elementsFilled = 0;
         private long then = System.nanoTime();

         @Override
         public void handle(long now) {
           long oldFrameTime = frameTimes[frameTimeIndex - 
elementsFilled % SIZE];
           long delta = now - then;

           frameTimes[frameTimeIndex] = now;
           frameDeltas[frameTimeIndex] = delta;
           frameTimeIndex = (frameTimeIndex + 1) % frameTimes.length;

           if(elementsFilled < SIZE) {
             elementsFilled++;
           }

           long elapsedNanos = now - oldFrameTime;
           long elapsedNanosPerFrame = elapsedNanos / elementsFilled;
           double frameRate = 1_000_000_000.0 / elapsedNanosPerFrame;
           double min = Double.MAX_VALUE;
           double max = 0;

           for(int i = 0; i < elementsFilled; i++) {
             min = Math.min(min, frameDeltas[i]);
             max = Math.max(max, frameDeltas[i]);
           }

           GraphicsContext g2d = canvas.getGraphicsContext2D();

           g2d.clearRect(frameTimeIndex, 0, 1, 100);
           g2d.strokeLine(frameTimeIndex, 100, frameTimeIndex, 100 - 
(delta) / 1000000.0);

           fpsLabel.setText(String.format(" %.1f/%.1f ms - %.1f fps", 
min / 1000000.0, max / 1000000.0, frameRate));

           then = now;
         }
       };

       frameRateMeter.start();

       fpsPane.setBackground(new Background(new 
BackgroundFill(Color.BLACK, CornerRadii.EMPTY, Insets.EMPTY)));

       Scene scene = new Scene(fpsPane);
       scene.setFill(Color.BLACK);
       stage = new Stage(StageStyle.TRANSPARENT);
       stage.setWidth(1500);
       stage.setHeight(1500);
       stage.setScene(scene);
       stage.show();
   }

   public static void main(String[] args) {
     launch(args);
   }
}
[prev in list] [next in list] [prev in thread] [next in thread]