modules/graphics/src/main/java/com/sun/javafx/tk/quantum/ViewPainter.java

*** 172,184 ****
  
          // This "g" variable might represent the back buffer graphics, or it
          // might be reassigned to the sceneBuffer graphics.
          Graphics g = backBufferGraphics;
          // Take into account the pixel scale factor for retina displays
!         final float pixelScale = getPixelScaleFactor();
          // Cache pixelScale in Graphics for use in 3D shaders such as camera and light positions.
!         g.setPixelScaleFactor(pixelScale);
  
          // Initialize renderEverything based on various conditions that will cause us to render
          // the entire scene every time.
          boolean renderEverything = overlayRoot != null ||
                  freshBackBuffer ||
--- 172,185 ----
  
          // This "g" variable might represent the back buffer graphics, or it
          // might be reassigned to the sceneBuffer graphics.
          Graphics g = backBufferGraphics;
          // Take into account the pixel scale factor for retina displays
!         final float pixelScaleX = getPixelScaleFactorX();
!         final float pixelScaleY = getPixelScaleFactorY();
          // Cache pixelScale in Graphics for use in 3D shaders such as camera and light positions.
!         g.setPixelScaleFactors(pixelScaleX, pixelScaleY);
  
          // Initialize renderEverything based on various conditions that will cause us to render
          // the entire scene every time.
          boolean renderEverything = overlayRoot != null ||
                  freshBackBuffer ||
*** 190,201 ****
          final boolean showDirtyOpts = PrismSettings.showDirtyRegions || PrismSettings.showOverdraw;
          // If showDirtyOpts is turned on and we're not using a depth buffer
          // then we will render the scene to an intermediate texture, and then at the end we'll
          // draw that intermediate texture to the back buffer.
          if (showDirtyOpts && !sceneState.getScene().getDepthBuffer()) {
!             final int bufferWidth = (int) Math.ceil(width * pixelScale);
!             final int bufferHeight = (int) Math.ceil(height * pixelScale);
              // Check whether the sceneBuffer texture needs to be reconstructed
              if (sceneBuffer != null) {
                  sceneBuffer.lock();
                  if (sceneBuffer.isSurfaceLost() ||
                          bufferWidth != sceneBuffer.getContentWidth() ||
--- 191,202 ----
          final boolean showDirtyOpts = PrismSettings.showDirtyRegions || PrismSettings.showOverdraw;
          // If showDirtyOpts is turned on and we're not using a depth buffer
          // then we will render the scene to an intermediate texture, and then at the end we'll
          // draw that intermediate texture to the back buffer.
          if (showDirtyOpts && !sceneState.getScene().getDepthBuffer()) {
!             final int bufferWidth = (int) Math.ceil(width * pixelScaleX);
!             final int bufferHeight = (int) Math.ceil(height * pixelScaleY);
              // Check whether the sceneBuffer texture needs to be reconstructed
              if (sceneBuffer != null) {
                  sceneBuffer.lock();
                  if (sceneBuffer.isSurfaceLost() ||
                          bufferWidth != sceneBuffer.getContentWidth() ||
*** 217,227 ****
                  renderEverything = true;
              }
              sceneBuffer.contentsUseful();
              // Hijack the "g" graphics variable
              g = sceneBuffer.createGraphics();
!             g.scale(pixelScale, pixelScale);
          } else if (sceneBuffer != null) {
              // We're in a situation where we have previously rendered to the sceneBuffer, but in
              // this render pass for whatever reason we're going to draw directly to the back buffer.
              // In this case we need to release the sceneBuffer.
              sceneBuffer.dispose();
--- 218,229 ----
                  renderEverything = true;
              }
              sceneBuffer.contentsUseful();
              // Hijack the "g" graphics variable
              g = sceneBuffer.createGraphics();
!             g.setPixelScaleFactors(pixelScaleX, pixelScaleY);
!             g.scale(pixelScaleX, pixelScaleY);
          } else if (sceneBuffer != null) {
              // We're in a situation where we have previously rendered to the sceneBuffer, but in
              // this render pass for whatever reason we're going to draw directly to the back buffer.
              // In this case we need to release the sceneBuffer.
              sceneBuffer.dispose();
*** 310,324 ****
                      // Set the clip rectangle using integer bounds since a fractional bounding box will
                      // still require a complete repaint on pixel boundaries
                      dirtyRect.setBounds(dirtyRegion);
                      // TODO I don't understand why this is needed. And if it is, are fractional pixelScale
                      // values OK? And if not, shouldn't pixelScale be an int instead?
!                     if (pixelScale != 1.0f) {
!                         dirtyRect.x *= pixelScale;
!                         dirtyRect.y *= pixelScale;
!                         dirtyRect.width *= pixelScale;
!                         dirtyRect.height *= pixelScale;
                      }
                      g.setClipRect(dirtyRect);
                      g.setClipRectIndex(i);
                      doPaint(g, getRootPath(i));
                  }
--- 312,326 ----
                      // Set the clip rectangle using integer bounds since a fractional bounding box will
                      // still require a complete repaint on pixel boundaries
                      dirtyRect.setBounds(dirtyRegion);
                      // TODO I don't understand why this is needed. And if it is, are fractional pixelScale
                      // values OK? And if not, shouldn't pixelScale be an int instead?
!                     if (pixelScaleX != 1.0f || pixelScaleY != 1.0f) {
!                         dirtyRect.x *= pixelScaleX;
!                         dirtyRect.y *= pixelScaleY;
!                         dirtyRect.width *= pixelScaleX;
!                         dirtyRect.height *= pixelScaleY;
                      }
                      g.setClipRect(dirtyRect);
                      g.setClipRectIndex(i);
                      doPaint(g, getRootPath(i));
                  }
*** 435,446 ****
          height = viewHeight = sceneState.getHeight();
  
          return sceneState.isWindowVisible() && !sceneState.isWindowMinimized();
      }
  
!     protected float getPixelScaleFactor() {
!         return presentable == null ? 1.0f : presentable.getPixelScaleFactor();
      }
  
      private void doPaint(Graphics g, NodePath renderRootPath) {
          // Null path indicates that occlusion culling is not used
          if (renderRootPath != null) {
--- 437,452 ----
          height = viewHeight = sceneState.getHeight();
  
          return sceneState.isWindowVisible() && !sceneState.isWindowMinimized();
      }
  
!     protected float getPixelScaleFactorX() {
!         return presentable == null ? 1.0f : presentable.getPixelScaleFactorX();
!     }
! 
!     protected float getPixelScaleFactorY() {
!         return presentable == null ? 1.0f : presentable.getPixelScaleFactorY();
      }
  
      private void doPaint(Graphics g, NodePath renderRootPath) {
          // Null path indicates that occlusion culling is not used
          if (renderRootPath != null) {