HandlingHighDPI

From WebGL Public Wiki
Jump to navigation Jump to search

Handling High DPI (Retina) displays in WebGL

There are an increasing number of devices on the market that have displays with very high pixel densities (DPI), such as the Macbook Pro with Retina display. WebGL applications can take advantage of the higher resolution these devices provide but doing so requires some code changes to the application itself. Fortunately these changes are minor and generally non-disruptive, which makes it easy to prepare your WebGL code for these new devices.

You can see a demo highlighting the difference accounting for High DPI displays can make at this location. (The two meshes will only appear different on a high DPI display.)

Resizing the Canvas

It's important to note that canvas elements, like most graphics elements, have 2 sizes.

  • the size they are displayed in the page
  • the size of their content

For a canvas element, the size of the content or drawingBuffer is determined by the width and height attributes of the canvas. The display size is determined by the CSS attributes applied to the canvas. For example:

<canvas width="111" height="222" style="width: 333px; height: 444px;"></canvas>

Defines a canvas that has a drawingBuffer, its content, of size 111x222 device pixels but is displayed at 333x444 CSS pixels.

On High DPI displays browsers will automatically upscale most content to ensure that it appears the right size on screen, which is done behind the scenes to prevent the majority of web sites from breaking. In the case of WebGL content, this causes the canvas to render at its usual resolution and then upscale to fit the canvas's display size. The practical effect of this is that an unmodified WebGL application may appear to be rendering at a lower-than-native resolution, which can introduce undesired aliasing.

To avoid this developers can scale the canvas width and height by the value of window.devicePixelRatio.

var desiredWidthInCSSPixels = 800;
var desiredHeightInCSSPixels = 600;

var canvas = document.getElementById("myCanvas");

// set the display size of the canvas.
canvas.style.width = desiredWidthInCSSPixels + "px";
canvas.style.height = desiredHeightInCSSPixels + "px";

// set the size of the drawingBuffer
var devicePixelRatio = window.devicePixelRatio || 1;
canvas.width = desiredWidthInCSSPixels * devicePixelRatio;
canvas.height = desiredHeightInCSSPixels * devicePixelRatio;

var gl = canvas.getContext("webgl");

The devicePixelRatio describes the ratio between CSS pixels and native device pixels. On most desktops and laptops with low DPI displays devicePixelRatio is 1, which means nothing will be scaled. On devices like the Retina Macbook Pro or Galaxy Nexus the devicePixelRatio is 2. These values aren't required to be integers, however: On the Nexus One the devicePixelRatio reports as 1.5.

Another method is to ask the browser what size the canvas is displayed and using that to set the size of the drawingBuffer.

<style>
 #theCanvas {
    width: 50%;
    height: 50%;
}
<style>
<canvas id="theCanvas"></canvas>
<script>
window.onload = main();

function main() {
  var canvas = document.getElementById("theCanvas");
  var devicePixelRatio = window.devicePixelRatio || 1;

  // set the size of the drawingBuffer based on the size it's displayed.
  canvas.width = canvas.clientWidth * devicePixelRatio;
  canvas.height = canvas.clientHeight * devicePixelRatio;

  var gl = canvas.getContext("webgl");
  ...
}
</script>

Several samples make these adjustments including the san angeles demo, the teapot demo, and the particles demo

Moire and Pixel-Snapping

In order to keep edges sharp, browsers do pixel-snapping or grid-fitting for DOM elements. This is done separately for the edges of the element. (If you make a non-integer-height element, as you move it down, you'll notice that the top and bottom edges snap at different times) Therefore, the height in device pixels is not round(css_height * devicePixelRatio), but rather round(css_bottom * dPR) - round(css_top * dPR). To ensure the rounding we expect, we can additionally then set elem.style.height = device_height / devicePixelRatio + 'px'.

For static canvases, it may be sufficient to snap the element to its nearest pixels:

function snap_to_pixels(e) {
  const e_rect = e.getBoundingClientRect();
  const DPR = window.devicePixelRatio;

  const device_rect = {};
  for (const k in e_rect) {
    if (k == 'toJSON') continue;
    device_rect[k] = Math.round(e_rect[k] * DPR);
  };

  e.style.position = 'fixed';
  e.style.top = device_rect.top / DPR + 'px';
  e.style.left = device_rect.left / DPR + 'px';
  e.style.width = device_rect.width / DPR + 'px';
  e.style.height = device_rect.height / DPR + 'px';

  return device_rect;
}

For canvases subject to reflow, a canvas can be placed within a div, and positioned on top of that div's pixels:

function snap_to_parent_pixels(e) {
  const p = e.parentNode;
  const p_rect = p.getBoundingClientRect();
  const DPR = window.devicePixelRatio;

  const device_rect = {};
  for (const k in p_rect) {
    if (k == 'toJSON') continue;
    device_rect[k] = Math.round(p_rect[k] * DPR);
  };

  e.style.position = 'fixed';
  e.style.top = device_rect.top / DPR + 'px';
  e.style.left = device_rect.left / DPR + 'px';
  e.style.width = device_rect.width / DPR + 'px';
  e.style.height = device_rect.height / DPR + 'px';

  return device_rect;
}

Handling Input

It's important to note that even though the resolution of the canvas has increased other values provided by the DOM will not adjust accordingly. A good example is mouse or touch input. Coordinates are still delivered in terms of CSS pixels, and thus must be transformed if you need them to line up exactly with the resized canvas pixels. You also need to keep in mind that the canvas position will still be reported in CSS pixels, so adjustments to account for element offsets should not use the devicePixelRatio.

canvas.addEventListener("mousemove", function(e) {
   var devicePixelRatio = window.devicePixelRatio || 1;
   var canvasX = (e.pageX - canvas.offsetLeft) * devicePixelRatio;
   var canvasY = (e.pageY - canvas.offsetTop) * devicePixelRatio;
   // Perform some operation with the transformed coordinates
}, false);

Rationale

Why doesn't the browser automatically make the drawingBuffer the size needed so that 1 pixel in the drawingBuffer equals 1 pixel displayed? The reason is the WebGL API has several features which are always in device pixels. If the browser automatically created a drawingBuffer of a different size than requested many programs would break.

Examples include but are not limited to lineWidth, scissor, viewport, gl_PointSize, gl_FragCoord, copyTexImage2D, and copyTexSubImage2D.