< prev index next > modules/javafx.graphics/src/main/java/com/sun/javafx/tk/quantum/QuantumToolkit.java
Print this page
}
}
rt.unlock();
}
- private int computeOptimumTileSize(int size, int maxSize) {
- return computeOptimumTileSize(size, maxSize, null);
- }
! private int computeOptimumTileSize(int size, int maxSize, boolean[] isDivExact) {
! // This method attempts to find the smallest exact divider for the provided `size`
! // while the result of the division is less than `maxSize`.
! // It tests all potential dividers from 2 to 6 and returns the result of the division
! // if all conditions can be satisfied or, failing that, `maxSize`.
- // If non-null, the value for `isDivExact` is set so as to reflect whether or not
- // an exact divider could be found.
- for (int n = 2; n <= 6; n++) {
int optimumSize = size / n;
if (optimumSize <= maxSize && optimumSize * n == size) {
- if (isDivExact != null && isDivExact.length > 0) {
- isDivExact[0] = true;
- }
return optimumSize;
}
}
- if (isDivExact != null && isDivExact.length > 0) {
- isDivExact[0]= false;
- }
return maxSize;
}
@Override
public void run() {
}
}
rt.unlock();
}
! private int computeTileSize(int size, int maxSize) {
! // If 'size' divided by either 2 or 3 produce an exact result
! // and is lesser that the specified maxSize, then use this value
! // as the tile size, as this makes the tiling process more efficient.
! for (int n = 1; n <= 3; n++) {
int optimumSize = size / n;
if (optimumSize <= maxSize && optimumSize * n == size) {
return optimumSize;
}
}
return maxSize;
}
@Override
public void run() {
// so we need to take several snapshot tiles and merge them into pImage
if (pImage.image == null) {
pImage.setImage(com.sun.prism.Image.fromIntArgbPreData(IntBuffer.allocate(w * h), w, h));
}
// Find out if it is possible to divide up the image in tiles of the same size
! int tileWidth = computeOptimumTileSize(w, maxTextureSize);
! var exactHeightDivFound = new boolean[]{false};
- int tileHeight = computeOptimumTileSize(h, maxTextureSize, exactHeightDivFound);
IntBuffer buffer = IntBuffer.allocate(tileWidth * tileHeight);
! // In order to minimize the number of time we have to resize the underlying
! // surface for capturing a tile, choose a dimension that has an exact divider
! // (if any) to be processed in the inner most loop.
! // E.g. looping on width then height in the example bellow requires four
! // surface resizing, whereas the opposite requires only two:
! //
! // for (w;;) for (h;;)
! // for(h;;) for(w;;)
! // ----------------- -----------------
! // | | | | | |
! // | 1 | 3 | | 1 | 2 |
! // h | | | h | | |
! // ----------------- -----------------
! // | 2 | 4 | | 3 | 4 |
! // ----------------- -----------------
! // w w
!
!
!
! if (exactHeightDivFound[0]) {
! for (int xOffset = 0; xOffset < w; xOffset += tileWidth) {
! tileWidth = Math.min(tileWidth, w - xOffset);
! for (int yOffset = 0; yOffset < h; yOffset += tileHeight) {
! tileHeight = Math.min(tileHeight, h - yOffset);
! renderTile(x, xOffset, y, yOffset, tileWidth, tileHeight,
! buffer, rf, tileRttCache, pImage);
! }
! }
! } else {
! for (int yOffset = 0; yOffset < h; yOffset += tileHeight) {
! tileHeight = Math.min(tileHeight, h - yOffset);
! for (int xOffset = 0; xOffset < w; xOffset += tileWidth) {
- tileWidth = Math.min(tileWidth, w - xOffset);
- renderTile(x, xOffset, y, yOffset, tileWidth, tileHeight,
- buffer, rf, tileRttCache, pImage);
- }
}
}
! } else {
// The requested size for the screenshot fits max texture size,
// so we can directly render it in the target image.
renderWholeImage(x, y, w, h, rf, pImage);
}
params.platformImage = pImage;
// so we need to take several snapshot tiles and merge them into pImage
if (pImage.image == null) {
pImage.setImage(com.sun.prism.Image.fromIntArgbPreData(IntBuffer.allocate(w * h), w, h));
}
// Find out if it is possible to divide up the image in tiles of the same size
! int tileWidth = computeTileSize(w, maxTextureSize);
! int tileHeight = computeTileSize(h, maxTextureSize);
IntBuffer buffer = IntBuffer.allocate(tileWidth * tileHeight);
!
! // M represents the middle set of tiles each with a size of tileW x tileH.
! // R is the right hand column of tiles,
! // B is the bottom row,
! // C is the corner:
! // +-----------+-----------+ . +-------+
! // | | | . | |
! // | M | M | . | R |
! // | | | . | |
! // +-----------+-----------+ . +-------+
! // | | | . | |
! // | M | M | . | R |
! // | | | . | |
! // +-----------+-----------+ . +-------+
! // . . . .
! // +-----------+-----------+ . +-------+
! // | B | B | . | C |
! // +-----------+-----------+ . +-------+
!
! // Walk through all same-size "M" tiles
! int xOffset = 0;
! int yOffset = 0;
! var mTileWidth = tileWidth;
! var mTileHeight = tileHeight;
! while (mTileWidth == tileWidth && xOffset < w) {
! yOffset = 0;
! mTileHeight = tileHeight;
! while (mTileHeight == tileHeight && yOffset < h) {
! renderTile(x, xOffset, y, yOffset, mTileWidth, mTileHeight,
! buffer, rf, tileRttCache, pImage);
! yOffset += tileHeight;
! mTileHeight = Math.min(tileHeight, h - yOffset);
}
+ xOffset += tileWidth;
+ mTileWidth = Math.min(tileWidth, w - xOffset);
}
! // Walk through remaining same-width "B" tiles, if any
+ int bOffset = 0;
+ int bTileHeight = tileHeight;
+ while (bTileHeight == tileHeight && bOffset < h) {
+ renderTile(x, xOffset, y, bOffset, mTileWidth, bTileHeight, buffer, rf, tileRttCache, pImage);
+ bOffset += tileHeight;
+ bTileHeight = Math.min(tileHeight, h - bOffset);
+ }
+ // Walk through remaining same-height "R" tiles, if any
+ int rOffset = 0;
+ int rTileWidth = tileWidth;
+ while (rTileWidth == tileWidth && rOffset < w) {
+ renderTile(x, rOffset, y, yOffset, rTileWidth, mTileHeight, buffer, rf, tileRttCache, pImage);
+ rOffset += tileWidth;
+ rTileWidth = Math.min(tileWidth, w - rOffset);
+ }
+ // Render corner "C" tile if needed
+ if (bOffset > 0 && rOffset > 0) {
+ renderTile(x, rOffset, y, bOffset, rTileWidth, bTileHeight, buffer, rf, tileRttCache, pImage);
+ }
+ }
+ else {
// The requested size for the screenshot fits max texture size,
// so we can directly render it in the target image.
renderWholeImage(x, y, w, h, rf, pImage);
}
params.platformImage = pImage;
< prev index next >