1. Introduction

This specification adds support of `composition` layers to the WebXR spec. The benefits of layers are as follows:

Performance and judder: Composition layers are presented at the frame rate of the compositor (i.e. native refresh rate of HMD) rather than at the application frame rate. Even when the application is not updating the layer’s rendering at the native refresh rate of the compositor, the compositor might be able to re-project the existing rendering to the proper pose. This results in smoother rendering and less judder. Another feature of layers is that each of them can have different resolution. This allows the application to scale down the main eye buffer resolution on low performance systems, but keeping essential information, such as text or a map, in its own layer at a higher resolution.
Legibility/visual fidelity: In regular WebXR, the resolution for eye-buffers might be reduced to relatively low values especially on low performance systems. This makes it harder to render high fidelity content, such as text. With Composition Layers, a static cylinder or quad layer can be drawn once at high resolution and is resampled only once by the compositor. This contrasts with the traditional approach with rendering an XRWebGLLayer where content is produced at the device’s refresh rate and resampled at least twice: once when rendering into WebGL eye-buffer (which can lose details due to lower eye-buffer resolution) and the second time by the compositor.
Power consumption / battery life: Due to the reduced rendering pipeline, the lack of double sampling and no need to update the layer’s rendering each frame, the power consumption is expected to be improved.
Latency: Pose sampling for composition layers may occur at the very end of the frame and then certain reprojection techniques could be used to update the layer’s pose to match it with the most recent HMD pose. This may significantly reduce the effective latency for the layers' rendering and as a result improve overall experience.
Support for more color types: WebXR only supports RGB values. Composition layer will have broader support for color types so authors can use compressed formats or sRGB.

1.1. Terminology

1.2. Application flow

If an author wants to use GL layers, they have to go through these steps:

For any layer type other than XRProjectionLayer request support through requiredFeatures or optionalFeatures in requestSession().
Create an XRWebGLBinding or XRMediaBinding.
Create layers with these objects.
Add the layers to XRRenderStateInit and call updateRenderState().
During requestAnimationFrame() for webgl layers, draw content each WebGL layer.

2. Initialization

If an application wants to create layers other than of type XRProjectionLayer during a session, the session MUST be requested with an appropriate feature descriptor. The string " layers " is introduced by this module as a new valid feature descriptor for the WebXR Layers feature.

Layers of type XRProjectionLayer MUST always be supported, regardless if the feature descriptor was requested.

The following code requests layers as an optional feature.

navigator . xr . requestSession (  'immersive-vr'  ,   {
    optionalFeatures :   [  'layers'  ]
   }

Layers are only supported for XRSessions created with XRSessionMode of "immersive-vr" or "immersive-ar". "inline" sessions MUST NOT support layers.

The "layers" feature descriptor has a feature requirement that it cannot be enabled when there is an active immersive session.

NOTE: This means that executing the request(permissionDesc) API with "layers" will not enable layers support for the current active session.

3. Layer types

3.1. Mono and stereo layers

A stereo layer MUST supply an XRSubImage to render to for each view.

A mono layer MUST supply a single XRSubImage which is shown to each view.

The XR Compositor MUST ensure that layers are presented correctly in stereo to the observer.

3.2. XRLayerLayout

The XRLayerLayout enum defines the layout of the layer.

 enum    XRLayerLayout   {
   "default" ,
   "mono" ,
   "stereo" ,
   "stereo-left-right" ,
   "stereo-top-bottom" 
};

A layout of default indicates that the layer can accomodate all the views of session’s list of views.
A layout of mono indicates that the layer is mono.
A layout of stereo indicates that the layer is stereo.
A layout of stereo-left-right indicates that the layer is stereo and divided left to right.
A layout of stereo-top-bottom indicates that the layer is stereo and divided top to bottom.

NOTE: If an XRCompositionLayer is created with a "default" or "stereo" XRLayerLayout, it is highly recommended that it is allocated with an "texture-array" texture type.

Note: The "stereo-left-right" and "stereo-top-bottom" layouts are designed to minimize draw calls for content that is already in stereo (for example stereo videos or images). Experiences that don’t require such assets types should use the "default" or "stereo" layout.

3.3. XRLayerQuality

The XRLayerQuality enum defines the display quality of the layer.

 enum    XRLayerQuality   {
   "default" ,
   "text-optimized" ,
   "graphics-optimized" 
};

A layout of default indicates that the layer is displayed with regular settings.
A layout of text-optimized indicates that XR Compositor will try to render the layer so it’s most readable.
A layout of graphics-optimized indicates that XR Compositor will try to render the layer with additional sharpness.

NOTE: the text-optimized and graphics-optimized flags MAY result in additional processing by the XR Compositor which may affect performance.

3.4. XRCompositionLayer

XRCompositionLayer defines a set of common attributes and behaviors across certain layer types.

[ Exposed = Window ]  interface    XRCompositionLayer   :  XRLayer  {
   readonly   attribute   XRLayerLayout   layout ;
   attribute   boolean   blendTextureSourceAlpha ;
   attribute   boolean   forceMonoPresentation ;
   attribute   float   opacity ;
   readonly   attribute   unsigned   long   mipLevels ;
   attribute   XRLayerQuality   quality ;
   readonly   attribute   boolean   needsRedraw ;
   undefined    destroy  ();
};

The layout attribute returns the layout of the layer.

The blendTextureSourceAlpha attribute enables the layer’s texture alpha channel.

The forceMonoPresentation attribute forces the right eye to use the same layer configuration as the left eye. This MUST send a signal to the XR Compositor to remove the stereo effect of this XRCompositionLayer. Setting this to true on a mono layer has no effect.

NOTE: this attribute has no other side effects on other information that is returned by the XRSession. Only the operation of the XR Compositor is affected by this setting and experiences SHOULD continue to draw to both eyes.

The opacity attribute sets the opacity that is applied to the pixels of the layer. The XR Compositor MUST multiply each pixel (in premultiplied space) by this value. opacity is 1.0 by default. Setting opacity to a value less than 0 will set it to 0 and setting it to a value higher than 1.0 will set it to 1.0.

The needsRedraw attribute signals that the XRCompositionLayer should be rerendered in the next XR animation frame. It MAY be set when the underlying resources of a layer are lost or when the XR Compositor can no longer reproject the layer. Failing to redraw the content in the next XR animation frame might cause flickering or other side effects.

The mipLevels attribute returns the depth of the mip chain. This MUST be equal or smaller than the value requested in mipLevels.

NOTE: some platforms don’t support mip levels. Authors should query mipLevels to determine if they can target a certain mip level and not rely on the value they passed in mipLevels.

The quality attribute sets and returns the quality of the XRCompositionLayer. default is the initial value.

When the underlying resources of a layer are lost for an XRCompositionLayer layer, the user agent MUST run the following steps:

Set layer’s needsRedraw to true.
If layer is not an XRProjectionLayer, queue a task to fire an event named redraw using XRLayerEvent on layer.

Each XRCompositionLayer has an associated destroyed boolean, initially false.

destroy() immediately marks the layer as destroyed and makes its graphics resources unavailable for future rendering. Calling destroy() on a layer that is already destroyed does nothing. A destroyed layer MUST NOT be presented by the XR Compositor, even if the layer is still present in the layers array while a pending render state update is applied.

If a method is invoked to obtain an XRSubImage for a destroyed layer, the method MUST throw an InvalidStateError.

Previously returned XRSubImage objects are not themselves destroyed when their layer is destroyed. Their attributes continue to return the same objects and values, but any graphics resources exposed by those objects MUST be invalidated for future rendering operations. GPU work queued before the resources were invalidated MAY complete.

To destroy the resources for a layer with an XRCompositionLayer layer, the user agent MUST run the following steps:

For each opaque texture in any of layer’s colorTextures, depthStencilTextures, or motionVectorTextures arrays that exist, mark the texture for deletion as though deleteTexture had been called with the texture on layer’s context. This is an internal user-agent operation and MUST NOT generate an INVALID_OPERATION error.
If layer is an XRProjectionLayer:
1. If layer’s colorTextures for secondary views is not null, for each opaque texture in that array, mark the texture for deletion in the same manner.
2. If layer’s depthStencilTextures for secondary views is not null, for each opaque texture in that array, mark the texture for deletion in the same manner.
If layer has a colorTextures array, set it to an empty array.
If layer has a depthStencilTextures array, set it to an empty array.
If layer has a motionVectorTextures array, set it to an empty array.
If layer is an XRProjectionLayer, set its colorTextures for secondary views and depthStencilTextures for secondary views to empty arrays.
For each of layer’s underlying resources, once all GPU work queued before the resource was invalidated has completed and the XR Compositor no longer accesses the resource, the user agent MAY physically release it.

When calling destroy() on an XRCompositionLayer layer, the user agent MUST run the following steps:

If layer’s destroyed is true, return.
Set layer’s destroyed to true.
Run destroy the resources for a layer with layer.
Let session be layer’s session.
If session’s pending render state is null:
1. If session’s active render state’s layers does not contain layer, return.
2. Set session’s pending render state to a copy of session’s active render state.
Let state be session’s pending render state.
If state’s layers is null or does not contain layer, return.
Set state’s layers to a new frozen array containing, in order, each entry in state’s layers other than layer.

Each XRCompositionLayer has a context object which is an instance of either null or a WebGLRenderingContext or a WebGL2RenderingContext and a media object which is an instance of null or a HTMLVideoElement.

Each XRCompositionLayer has an associated session , which is the XRSession it was created with.

When setting the space on a layer with XRSpace space and XRCompositionLayer layer, the user agent MUST run the following steps to validate if the space is valid:

If space is null, throw TypeError and abort these steps.
If space’s session is not equal to the layer’s session, throw TypeError and abort these steps.

XRCompositionLayer has an internal boolean isStatic that indicates that the author can only draw to this layer when needsRedraw is true.

NOTE: if isStatic is true the author can only draw into the layer once after creation or once after a redraw event. This allows the UA to only allocate a single GPU buffer.

When a writeable attribute is set on an XRCompositionLayer or any of its derived classes, reading that attribute MUST return that value. At the end of the requestAnimationFrame() callback, the value MUST be sent to the underlying XR Compositor. The XR Compositor MUST apply the value next time it presents the XRFrame that was passed to the requestAnimationFrame() callback.

NOTE: this means that the values must be applied when the XR Compositor redraws the scene using the new XRFrame, even if there was no change in the colorTexture associated with the XRCompositionLayer or the videoframe associated with a media layer. If the XR Compositor redraws the scene with the previous XRFrame’s state, it must not use the new values.

3.5. XRProjectionLayer

An XRProjectionLayer is a layer that fills the entire view of the observer. Projection layers should be refreshed close to the device’s native frame rate.

representation of a projection layer

[ Exposed = Window ]  interface    XRProjectionLayer   :  XRCompositionLayer  {
   readonly   attribute   unsigned   long   textureWidth ;
   readonly   attribute   unsigned   long   textureHeight ;
   readonly   attribute   unsigned   long   textureArrayLength ;
   readonly   attribute   boolean   ignoreDepthValues ;
   attribute   float ?  fixedFoveation ;
   attribute   XRRigidTransform ?  deltaPose ;
};

The textureWidth attribute returns the width in pixels of the colorTextures textures of this layer.

The textureHeight attribute returns the height in pixels of the colorTextures textures of this layer.

The textureArrayLength attribute returns the number of layers of the colorTextures textures of this layer if the XRProjectionLayer was initialized with a textureType of "texture-array". Otherwise it will return 1.

The fixedFoveation attribute controls the amount of foveation used by the XR Compositor. If the user agent or device does not support this attribute, they should return null on getting, and setting should be a no-op. Setting fixedFoveation to a value less than 0 will set it to 0 and setting it to a value higher than 1 will set it to 1. 0 sets the minimum amount of foveation while 1 set the maximum. It is up to the user agent how the XR Compositor interprets these values. If the fixedFoveation level was changed, it will take effect at the next XRFrame.

The ignoreDepthValues attribute, if true, indicates that the XR Compositor MUST NOT make use of values in the depth buffer attachment when rendering. When the attribute is false it indicates that the content of the depth buffer attachment will be used by the XR Compositor and is expected to be representative of the scene rendered into the layer.

The deltaPose attribute describes the incremental application-applied transform, if any, since the previous frame that affects the view. If the user agent or device does not support this attribute or the "space-warp" feature descriptor was not requested, the user agent should return null on getting, and setting should be a no-op. A null value indicates that no application-applied transform is being supplied. The value of deltaPose persists until the author changes it; the user agent does not reset it at the end of an requestAnimationFrame() callback. When artificial locomotion transforms the world from one application pose to another between frames, setting deltaPose to the difference between those poses helps the XR Compositor synthesize missing frames. Authors should update deltaPose when that transform changes and set it to null or an identity transform for frames where no application-applied transform occurred.

3.6. XRQuadLayer

An XRQuadLayer renders a layer that takes up a flat rectangular space in the virtual environment. Only the front of the layer MUST be visible; the back face MUST NOT be drawn by the XR Compositor.

A XRQuadLayer has no thicknes. It is a two-dimensional object positioned and oriented in 3D space. The position of a quad refers to the center of the quad.

representation of a quad layer

[ Exposed = Window ]  interface    XRQuadLayer   :  XRCompositionLayer  {
   attribute   XRSpace   space ;
   attribute   XRRigidTransform   transform ;
   attribute   float   width ;
   attribute   float   height ;
  // Events
   attribute   EventHandler   onredraw ;
};

The transform attributes sets and returns the offset and orientation relative to the space attribute. The transform and space attributes establish the spatial relationship of the layer within the user’s physical environment. When setting the space, first run the steps for setting the space on a layer.

The width and height attributes set and return the width and height of the layer in meters.

When initializing an XRQuadLayer layer with an XRQuadLayerInit init , the user agent MUST run the following steps:

Initialize layer’s width to init’s width.
Initialize layer’s height to init’s height.
Let layer’s space be the init’s space.
Initialize layer’s transform as follows:

If init’s transform is set
Let layer’s transform be a new XRRigidTransform in the relevant realm of layer initialized with position and orientation of init’s transform.
Otherwise
Let layer’s transform be a new XRRigidTransform in the relevant realm of layer initialized with a DOMPointInit position of { x: 0.0, y: 0.0, z: 0.0, w: 1.0 }.
Initialize layer’s isStatic to init’s isStatic

The onredraw attribute is an Event handler IDL attribute for the redraw event type.

3.7. XRCylinderLayer

An XRCylinderLayer renders a layer that takes up a curved rectangular space in the virtual environment. Only the front of the layer MUST be visible; the back face MUST NOT be drawn by the XR Compositor.

representation of a cylinder layer

A XRCylinderLayer has no thicknes. It is a two-dimensional object positioned and oriented in 3D space. The position of the cylinder refers to the center of the quad.

[ Exposed = Window ]  interface    XRCylinderLayer   :  XRCompositionLayer  {
   attribute   XRSpace   space ;
   attribute   XRRigidTransform   transform ;
   attribute   float   radius ;
   attribute   float   centralAngle ;
   attribute   float   aspectRatio ;
  // Events
   attribute   EventHandler   onredraw ;
};

The transform attribute sets and returns the offset and orientation relative to the space attribute. The transform and space attributes establish the spatial relationship of the layer within the user’s physical environment. When setting the space, first run the steps for setting the space on a layer.

The radius attribute controls the radius in meters of the cylinder.

The centralAngle attribute controls the angle in radians of the visible section of the cylinder. It grows symmetrically around the 0 angle.

The aspectRatio attribute controls the ratio of the visible cylinder section. It is the ratio of the width of the visible section of the cylinder divided by its height. The width is calculated by multiplying the radius with the centralAngle.

description of the parameters of a cylinder layer

When initializing an XRCylinderLayer layer with an XRCylinderLayerInit init , the user agent MUST run the following steps:

Initialize layer’s radius to init’s radius.
Initialize layer’s centralAngle to init’s centralAngle.
Initialize layer’s aspectRatio to init’s aspectRatio.
Let layer’s space be the init’s space.
Initialize layer’s transform as follows:

If init’s transform is set
Let layer’s transform be a new XRRigidTransform in the relevant realm of layer initialized with position and orientation of init’s transform.
Otherwise
Let layer’s transform be a new XRRigidTransform in the relevant realm of layer initialized with a DOMPointInit position of { x: 0.0, y: 0.0, z: 0.0, w: 1.0 }.
Initialize layer’s isStatic to init’s isStatic

The onredraw attribute is an Event handler IDL attribute for the redraw event type.

3.8. XREquirectLayer

An XREquirectLayer renders a layer where the XR Compositor MUST map an equirectangular coded data onto the inside of a sphere.

representation of an equirect layer

this section needs clarification

[ Exposed = Window ]  interface    XREquirectLayer   :  XRCompositionLayer  {
   attribute   XRSpace    space  ;
   attribute   XRRigidTransform   transform ;
   attribute   float   radius ;
   attribute   float   centralHorizontalAngle ;
   attribute   float   upperVerticalAngle ;
   attribute   float   lowerVerticalAngle ;
  // Events
   attribute   EventHandler   onredraw ;
};

The transform attribute sets and returns the offset and orientation relative to space. The transform attribute and the space establish the spatial relationship of the layer within the user’s physical environment.

The radius attribute is the non-negative radius in meters of the sphere. Values of zero or infinity are treated as an infinite sphere.

Setting radius to a value less than 0 will set it to 0.

The centralHorizontalAngle , upperVerticalAngle and lowerVerticalAngle attributes set and return how the texture is mapped to the sphere.

Setting centralHorizontalAngle to a value less than 0 will set it to 0 and setting it to a value higher than 2π will set it to 2π.

Setting upperVerticalAngle or lowerVerticalAngle to a value less than -π/2 will set it to -π/2 and setting it to a value higher than π/2 will set it to π/2.

description of the parameters of an equirect layer

When assigning an XRSpace to the space attribute, first run the following steps.

When setting the space on an equirect layer with XRSpace space and XREquirectLayer layer, the user agent MUST run the following steps to validate if the space is valid:

If init’s space is not an instance of type XRReferenceSpace, throw TypeError and abort these steps.
If init’s space has a type of "viewer", throw TypeError and abort these steps.
Run setting the space on a layer with space and layer.

The onredraw attribute is an Event handler IDL attribute for the redraw event type.

3.9. XRCubeLayer

A XRCubeLayer renders a layer where the XR Compositor renders directly from a cubemap.

representation of a cube layer

this section needs clarification

[ Exposed = Window ]  interface    XRCubeLayer   :  XRCompositionLayer  {
   attribute   XRSpace   space ;
   attribute   DOMPointReadOnly   orientation ;
  // Events
   attribute   EventHandler   onredraw ;
};

The orientation attribute sets and returns the orientation relative to the space attribute. The orientation and space attributes establish the spatial relationship of the layer within the user’s physical environment. When placing the XRCubeLayer only the orientation of the space is considered. The cube layer will always be rendered with the view point at the center.

When assigning an XRSpace to the space attribute, first run the following steps.

When setting the space on an cube layer with XRSpace space and XRCubeLayer layer, the user agent MUST run the following steps to validate if the space is valid:

If init’s space is not an instance of type XRReferenceSpace, throw TypeError and abort these steps.
If init’s space has a type of "viewer", throw TypeError and abort these steps.
Run setting the space on a layer with space and layer.

The onredraw attribute is an Event handler IDL attribute for the redraw event type.

4. Spaces

XRProjectionLayer and XRWebGLLayer don’t have associated an XRSpace because they render to the full frame.

XRCubeLayer and XREquirectLayer MUST only support XRReferenceSpaces that are not of type "viewer".

XRQuadLayer and XRCylinderLayer MUST support all XRSpace types.

Generally, developers should not use of "viewer" space to stabilize layers, as this will almost always defeat positional or rotational reprojection and result in a loss in stability of the rendered content relative to the world. The exception being small UI elements like a gaze cursor or targeting reticle.

Following are some best practices of spaces to use with a layer type:

XRQuadLayer with "viewer" space: Head-locked constant-size reticle in center of screen.
XRQuadLayer or XRCylinderLayer in "local", "unbounded" space: springy body-locked UI.
XRQuadLayer or XRCylinderLayer in "local", "local-floor", "unbounded", "bounded-floor" or anchor space: world-locked video, placed by the user.
XREquirectLayer or XRCubeLayer in "local" space: 360-degree video or skybox.

5. Rendering

5.1. XRSubImage

The XRSubImage object represents what viewport of the color GPU texture to use.

[ Exposed = Window ]  interface    XRSubImage   {
  [ SameObject ]  readonly   attribute   XRViewport   viewport ;
};

NOTE: this class is designed to accomodate future extensions

The viewport attribute returns the XRViewport to use when rendering the sub image’s color attachment.

5.2. XRWebGLSubImage

The XRWebGLSubImage object is used during rendering of the layer.

[ Exposed = Window ]  interface    XRWebGLSubImage   :  XRSubImage  {
  [ SameObject ]  readonly   attribute   WebGLTexture   colorTexture ;
  [ SameObject ]  readonly   attribute   WebGLTexture ?  depthStencilTexture ;
  [ SameObject ]  readonly   attribute   WebGLTexture ?  motionVectorTexture ;
   readonly   attribute   unsigned   long ?  imageIndex ;
   readonly   attribute   unsigned   long   colorTextureWidth ;
   readonly   attribute   unsigned   long   colorTextureHeight ;
   readonly   attribute   unsigned   long ?  depthStencilTextureWidth ;
   readonly   attribute   unsigned   long ?  depthStencilTextureHeight ;
};

The colorTexture attribute returns the color opaque texture for the XRCompositionLayer. The viewport describes the region of the colorTexture that corresponds to the requested view. It does not describe the region of the depthStencilTexture or motionVectorTexture.

The depthStencilTexture attribute returns the depth/stencil opaque texture for the XRCompositionLayer. If the layer was created without depth/stencil, this attribute returns null.

The motionVectorTexture attribute returns the motion opaque texture for the XRProjectionLayer. If the XRSession was created without the space-warp feature descriptor or the layer is not a XRProjectionLayer, this attribute MUST return null.

The imageIndex attribute returns the offset into the texture array. Valid only for layers that were requested with texture-array.

The colorTextureWidth and colorTextureHeight attributes return the width and height in pixels of the GL color attachments.

The depthStencilTextureWidth and depthStencilTextureHeight attributes return the width and height in pixels of the GL depth/stencil attachments. If the layer was created without depth/stencil, these attributes return null.

5.3. XRTextureType

The XRTextureType enum defines what type of texture is allocated.

 enum    XRTextureType   {
   "texture" ,
   "texture-array" 
};

A texture type of texture indicates that the textures of XRWebGLSubImage MUST be of type TEXTURE_2D
A texture type of texture-array indicates that the textures of XRWebGLSubImage MUST be of type TEXTURE_2D_ARRAY

6. GPU layer and view creation

6.1. Overview

When a layer is created it is backed by a GPU resource, typically a texture, provided by one of the Web platform’s graphics APIs. In order to specify which API is providing the layer’s GPU resources an XRWebGLBinding for the API in question must be created. Each graphics API may have unique requirements that must be satisfied before a context can be used in the creation of a layer. For example, a WebGLRenderingContext must have its xrCompatible flag set prior to being passed to the constructor of the XRWebGLBinding instance.

Any interaction between the XRSession the graphics API, such as allocating or retrieving textures, will go through this XRWebGLBinding instance, and the exact mechanics of the interaction will typically be API specific. This allows the rest of the WebXR API to be graphics API agnostic and more easily adapt to future advances in rendering techniques.

Once an XRWebGLBinding instance has been acquired, it can be used to create a variety of XRCompositionLayer. Any layers created by that instance will then be able to query the associated GPU resources each frame, generally expected to be the native API’s texture interface.

The various layer types are created with the create____Layer series of methods on the XRWebGLBinding instance. Information about the graphics resources required, such as whether or not to allocate a depth buffer or alpha channel, are passed in at layer creation time and will be immutable for the lifetime of the layer. The method will return the associated XRCompositionLayer type.

If an XRSession was created with the "layers" feature descriptor, it MUST support all layer types. If a layer type isn’t supported its creation method MUST throw an exception. XRProjectionLayer MUST be supported by all XRSessions, whether it was created with the "layers" feature descriptor or not.

6.2. Opaque textures

When using WebXR GPU layers, the XRWebGLBinding object will return instances of an opaque texture for the color and depth/stencil attachments.

An opaque texture functions identically to a standard WebGLTexture with the following changes:

An opaque texture is considered invalid outside of a requestAnimationFrame() callback for its session.
An opaque texture is invalid until it is returned by the getSubImage() or getViewSubImage() calls.
The XR Compositor MUST assume that the opaque texture for the color attachment contains colors with premultiplied alpha.
At the end of the requestAnimationFrame() callback the texture MUST be unbounded and detached from all WebGLShader objects.
An opaque texture MUST behave as though it was allocated with texStorage2D or texStorage3D, as appropriate, even when using a WebGL 1.0 context.
A call to deleteTexture with an opaque texture MUST generate an INVALID_OPERATION error.

The buffers attached to an opaque texture MUST be cleared to the values in the table below during the processing of the first call to getViewSubImage() or getSubImage() in each XR animation frame when clearOnAccess is true. If clearOnAccess is false, the buffers attached to an opaque texture MUST be cleared the first time that they are accessed. Subsequent accesses in later frames MAY NOT clear the buffers.

Buffer	Clear Value
Color	(0, 0, 0, 0)
Depth	1.0
Stencil	0

If the opaque texture was created with 2 or more mipLevels, the author SHOULD populate all the mip levels. The user agent MUST NOT assume that it should create the mip levels.

NOTE: the opaque textures are allocated when the layer is contructed using the allocate color textures and allocate depth textures algoritms. The side effect of this pre-allocation is that calling getSubImage() and getViewSubImage() with the same parameters will always return the same texture objects.

NOTE: Changes to the dimensions or format of the opaque textures are not allowed. GL commands may only alter the texel values and texture parameters. Using any of the following commands with the WebGLTexture will result in an INVALID_OPERATION error being generated, even if it does not affect the dimensions or format: TexImage*, CompressedTexImage*, CopyTexImage* and TexStorage*. The "Immutable-Format Texture Images" section in the OpenGL ES 3.0 spec defines these limitations in more detail.

Allocation of the resources for layers (such as memory) MUST be done through the same mechanism as WebGL.

If an XRLayer is allocated with the RGBA or RGB colorFormat, its colorTextures MUST be exposed as RGBA or RGB to the WebGLRenderingContext context. However, the XR Compositor MUST treat the colorTextures’s pixels as if they were in the SRGB8_ALPHA8 or SRGB8 colorFormat.

NOTE: this means that the XR Compositor MUST NOT do any gamma conversion from linear RGBA or RGB when it processes the colorTextures. Otherwise, the pixels in the final rendering will appear too bright which will not match the rendering on a regular 2D WebGLRenderingContext context.

6.3. XRProjectionLayerInit

The XRProjectionLayerInit dictionary represents a set of configurable values that describe how an XRProjectionLayer is initialized.

 dictionary    XRProjectionLayerInit   {
   XRTextureType   textureType  = "texture";
   GLenum   colorFormat  = 0x1908; // RGBA
   GLenum   depthFormat  = 0x1902; // DEPTH_COMPONENT
   double   scaleFactor  = 1.0;
   boolean   clearOnAccess  =  true ;
};

The textureType attribute defines the type of texture that the layer will have.

The colorFormat attribute defines the data type of the color texture data.

This is the list of color formats for projection layers that the XR Compositor MUST support:

RGBA
RGB
SRGB_EXT for contexts with the 'EXT_sRGB' extension enabled
SRGB_ALPHA_EXT for contexts with the 'EXT_sRGB' extension enabled

For WebGL2 contexts these additional formats are supported:

The depthFormat attribute defines the data type of the depth texture data. If depthFormat is 0 the layer will not provide a depth/stencil texture.

This is the list of depth formats for projection layers that the XR Compositor MUST support:

For WebGLRenderingContext contexts with the 'WEBGL_depth_texture' extension enabled or WebGL2 contexts:

DEPTH_COMPONENT
DEPTH_STENCIL

If the extension was not enabled, the request for a depth texture is ignored.

NOTE: this could be confusing to authors because they might expect a depth texture. If possible, provide a warning with the reason why the texture was not created.

For WebGL2RenderingContext contexts these additional formats are supported:

DEPTH_COMPONENT24
DEPTH24_STENCIL8

The scaleFactor attribute defines the value that the session’s recommended WebGL framebuffer resolution MUST be multiplied by determining the resolution of the layer’s attachments.

The clearOnAccess attribute defines if the texture associated with this layer should be cleared in the initial frame or on every frame.

NOTE: the XRProjectionLayerInit dictionary does not have support to configure mipLevels like XRLayerInit. If a user agent wants to support mipmapping on projection layers, it is free to allocate the texture with mips. In that case the user agent (and not the author) is responsible for generating all the mip levels.

6.4. XRLayerInit

The XRLayerInit dictionary represents a set of common configurable values for XRQuadLayer, XRCylinderLayer, XREquirectLayer and XRCubeLayer .

 dictionary    XRLayerInit   {
   required   XRSpace   space ;
   XRTextureType   textureType  = "texture";
   GLenum   colorFormat  = 0x1908; // RGBA
   GLenum ?  depthFormat ;
   unsigned   long   mipLevels  = 1;
   required   unsigned   long   viewPixelWidth ;
   required   unsigned   long   viewPixelHeight ;
   XRLayerLayout   layout  = "mono";
   boolean    isStatic   =  false ;
   boolean   clearOnAccess  =  true ;
};

The space attribute defines the spatial relationship with the user’s physical environment.

The textureType attribute defines the type the layer’s textures. The XR Compositor MUST support:

"texture"

For WebGL2RenderingContext these additional types are supported:

"texture-array"

The colorFormat attribute defines the data type of the color texture data.

This is the list of color formats for non-projection layers that the XR Compositor MUST support:

RGBA
RGB
SRGB_EXT for contexts with the 'EXT_sRGB' extension enabled
SRGB_ALPHA_EXT for contexts with the 'EXT_sRGB' extension enabled

For WebGL2 contexts these additional formats are supported:

For contexts with the 'WEBGL_compressed_texture_etc' extension enabled these additional formats are supported:

For contexts with the 'WEBGL_compressed_texture_astc' extension enabled all the formats of that extension are supported.

The depthFormat attribute defines the data type of the depth texture data. If depthFormat is not supplied, the layer will not provide a depth/stencil texture.

This is the list of depth formats for non-projection layers that the XR Compositor MUST support:

For WebGLRenderingContext contexts with the 'WEBGL_depth_texture' extension enabled or WebGL2 contexts:

DEPTH_COMPONENT
DEPTH_STENCIL

For WebGL2RenderingContext contexts these additional formats are supported:

DEPTH_COMPONENT24
DEPTH24_STENCIL8

The mipLevels attribute defines the desired number of mip levels in the color and texture data. If the user agent can’t create the requested number, it can create less. Authors MUST query mipLevels to determine the actual number of mip levels.

The viewPixelWidth and viewPixelHeight attributes define the rectangular dimensions of the XRCompositionLayer.

The layout attribute defines the layout of the layer.

The clearOnAccess attribute defines if the texture associated with this layer should be cleared in the initial frame or on every frame.

6.5. XRQuadLayerInit

The XRQuadLayerInit dictionary represents a set of configurable values that describe how an XRQuadLayer is initialized.

 dictionary    XRQuadLayerInit   :  XRLayerInit  {
   XRRigidTransform ?   transform  ;
   float    width   = 1.0;
   float    height   = 1.0;
};

6.6. XRCylinderLayerInit

The XRCylinderLayerInit dictionary represents a set of configurable values that describe how an XRCylinderLayer is initialized.

 dictionary    XRCylinderLayerInit   :  XRLayerInit  {
   XRRigidTransform ?   transform  ;
   float    radius   = 2.0;
   float    centralAngle   = 0.78539;
   float    aspectRatio   = 2.0;
};

The default value of centralAngle is π / 4.

6.7. XREquirectLayerInit

The XREquirectLayerInit dictionary represents a set of configurable values that describe how an XREquirectLayer is initialized.

 dictionary    XREquirectLayerInit   :  XRLayerInit  {
   XRRigidTransform ?   transform  ;
   float    radius   = 0;
   float    centralHorizontalAngle   = 6.28318;
   float    upperVerticalAngle   = 1.570795;
   float    lowerVerticalAngle   = -1.570795;
};

The default value of centralHorizontalAngle is 2π. The default value of upperVerticalAngle is π/2. The default value of lowerVerticalAngle is -π/2.

6.8. XRCubeLayerInit

The XRCubeLayerInit dictionary represents a set of configurable values that describe how an XRCubeLayer is initialized.

 dictionary    XRCubeLayerInit   :  XRLayerInit  {
   DOMPointReadOnly ?   orientation  ;
};

6.9. XRWebGLBinding

The XRWebGLBinding object is used to create layers that have a GPU backend.

[ Exposed = Window ]  interface    XRWebGLBinding   {
   constructor ( XRSession    session  ,  XRWebGLRenderingContext    context  );
   readonly   attribute   double   nativeProjectionScaleFactor ;
   readonly   attribute   boolean   usesDepthValues ;
   XRProjectionLayer   createProjectionLayer ( optional   XRProjectionLayerInit    init   = {});
   XRQuadLayer   createQuadLayer ( optional   XRQuadLayerInit    init   = {});
   XRCylinderLayer   createCylinderLayer ( optional   XRCylinderLayerInit    init   = {});
   XREquirectLayer   createEquirectLayer ( optional   XREquirectLayerInit    init   = {});
   XRCubeLayer   createCubeLayer ( optional   XRCubeLayerInit    init   = {});
   XRWebGLSubImage   getSubImage ( XRCompositionLayer    layer  ,  XRFrame    frame  ,  optional   XREye    eye   = "none");
   XRWebGLSubImage   getViewSubImage ( XRProjectionLayer    layer  ,  XRView    view  );
   undefined   foveateBoundTexture ( GLenum    target  ,  float    fixed_foveation  );
};

the init dictionaries shouldn’t be optional. This is bikeshed issue 1566.

Each XRWebGLBinding has a context object of type XRWebGLRenderingContext which is an instance of either a WebGLRenderingContext or a WebGL2RenderingContext.

Each XRWebGLBinding has an associated session , which is the XRSession it was created with.

Each XRWebGLBinding has an internal WeakSet foveatedTextures that holds weak references to the textures that were bound to the specified target when calling foveateBoundTexture.

NOTE: It is possible to create more than one XRWebGLBinding. Any layer created with an instance of XRWebGLBinding can be used with another instance of XRWebGLBinding as long as both were created with the same session and the same context. The lifetime of layers or instances of XRWebGLSubImage is not tied to the lifetime of the XRWebGLBinding that created them.

Each XRCompositionLayer created through XRWebGLBinding has an internal colorTextures array which is an array of WebGLTextures for color textures, an internal depthStencilTextures which is an array of opaque textures for depth/stencil textures and an internal motionVectorTextures which is an array of opaque textures for motion textures.

Each XRProjectionLayer created through XRWebGLBinding has an internal colorTextures for secondary views array which is an array of opaque textures for color textures and an internal depthStencilTextures for secondary views array which is an array of opaque textures for depth/stencil textures that are used to render the secondary views.

The nativeProjectionScaleFactor function returns the value that the session’s recommended WebGL framebuffer resolution MUST be multiplied by to yield the session’s native WebGL framebuffer resolution.

special case UA behavior if the size causes the layout to change (ie if the requested width exceeds a limit with "stereo-left-right")

The usesDepthValues attribute, if false, indicates that the XR Compositor MUST NOT make use of values if there is a depth buffer attachment. When the attribute is true it indicates that the content of the depth buffer attachment will be used by the XR Compositor and is expected to be representative of the scene rendered into the layer.

To determine the layout attribute using an XRTextureType textureType, an XRWebGLRenderingContext context and an XRLayerLayout layout, the user agent MUST run the following steps:

If context is not an WebGL2RenderingContext and textureType is "texture-array", throw TypeError and abort these steps.
If textureType is "texture-array" and not all of the session’s views in the list of views have the same recommended WebGL color texture resolution, throw a NotSupportedError and abort these steps.
If layout is "mono", return layout and abort these steps.
If layout is "default", run the following steps:
1. If the size of list of views is 1, return "mono" and abort these steps.
2. If textureType is "texture-array", return layout and abort these steps.
If layout is "default" or "stereo" and textureType is "texture", run the following steps:
1. If the user agent prefers "stereo-left-right" layout, return "stereo-left-right" and abort these steps.
2. If the user agent prefers "stereo-top-bottom" layout, return "stereo-top-bottom" and abort these steps.
return layout.

To determine the maximum scalefactor using an XRSession session, an XRWebGLRenderingContext context and an XRLayerLayout layout, the user agent MUST run the following steps:

Let largest width be the largest width of the recommended WebGL color texture resolution from the session’s list of views excluding the secondary views.
Let largest height be the largest height of the recommended WebGL color texture resolution from the session’s list of views excluding the secondary views.
If layout is "stereo-left-right" layout, multiply largest width by 2.
If layout is "stereo-top-bottom" layout, multiply largest height by 2.
Let largest view dimension be the largest of largest width or largest height.
Let largest texture dimension be the largest dimension of a WebGLTexture created by context.
return largest texture dimension divided by largest view dimension.

To allocate color textures for projection layers using an XRProjectionLayer layer, an XRTextureType textureType, a GLenum textureFormat and a float scaleFactor, the user agent MUST run the following steps:

Let array be a new array in the relevant realm of context.
Let context be layer’s context.
Let session be layer’s session.
Let numViews be the number of the session’s list of views excluding the secondary views.
Let view be the first entry in the session’s list of views that is not a secondary views.
Let width be the width of view’s recommended WebGL color texture resolution multiplied by scaleFactor.
Let height be the height of view’s recommended WebGL color texture resolution multiplied by scaleFactor.
If textureFormat is not in the list of color formats for projection layers, throw a NotSupportedError and abort these steps.
If layer’s layout is "mono" or "default":
If textureType is "texture-array":
If the session’s views in the list of views don’t all have the same recommended WebGL color texture resolution excluding the secondary views, throw a NotSupportedError and abort these steps.
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with numViews layers using context, textureFormat, width and height.
If the opaque texture was unable to be created for any reason, throw an OperationError and abort these steps.
Return array and abort these steps.
Otherwise
For each view in the session’s list of views:
1. If view is a secondary view, continue.
2. Let width be the width of view’s recommended WebGL color texture resolution multiplied by scaleFactor.
3. Let height be the height of view’s recommended WebGL color texture resolution multiplied by scaleFactor.
4. let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context, textureFormat, width and height.
5. If the texture was unable to be created for any reason, throw an OperationError and abort these steps.
6. Append texture to array.
Return array and abort these steps.
If the session’s views in the list of views don’t all have the same recommended WebGL color texture resolution excluding the secondary views, throw a NotSupportedError and abort these steps.
If layer’s layout is stereo-left-right, initialize array with 1 new instance of opaque texture in the relevant realm of context created as a textureType texture using context , textureFormat, numViews multiplied by width and height.
If layer’s layout is stereo-top-bottom, initialize array with 1 new instance of opaque texture in the relevant realm of context created as a textureType texture using context , textureFormat, width and numViews multiplied by height.
If the opaque texture was unable to be created for any reason, throw an OperationError and abort these steps.
return array.

To allocate depth textures for projection layers using an XRProjectionLayer layer, an XRTextureType textureType, a GLenum textureFormat and a float scaleFactor, the user agent MUST run the following steps:

Let context be layer’s context.
Let array be a new array in the relevant realm of context.
Let session be layer’s session.
If textureFormat is 0, return array and abort these steps.
If context is a WebGLRenderingContext and the WEBGL_depth_texture extension is not enabled in context, return array and abort these steps.
If textureFormat is not in the list of depth formats for projection layers, throw a NotSupportedError and abort these steps.
let numViews be the number of the session’s list of views excluding the secondary views.
Let view be the first entry in the session’s list of views that is not a secondary view.
Let recommendedDepthResolution be view’s recommended WebGL depth texture resolution.
If session was created with the "space-warp" feature descriptor, set recommendedDepthResolution to view’s recommended motion vector texture resolution.
Let width be the width of recommendedDepthResolution multiplied by scaleFactor.
Let height be the height of recommendedDepthResolution multiplied by scaleFactor.
If layer’s layout is "mono" or "default":
If textureType is "texture-array":
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with numViews layers using context, textureFormat, stencil, width and height.
If the opaque texture was unable to be created for any reason, throw an OperationError and abort these steps.
Return array and abort these steps.
Otherwise
For each view in the session’s list of views:
1. If view is a secondary view, continue.
2. Let recommendedDepthResolution be view’s recommended WebGL depth texture resolution.
3. If session was created with the "space-warp" feature descriptor, set recommendedDepthResolution to view’s recommended motion vector texture resolution.
4. Let width be the width of recommendedDepthResolution multiplied by scaleFactor.
5. Let height be the height of recommendedDepthResolution multiplied by scaleFactor.
6. let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context, textureFormat, stencil, width and height.
7. If the texture was unable to be created for any reason, throw an OperationError and abort these steps.
8. Append texture to array.
Return array and abort these steps.
If session was created with the "space-warp" feature descriptor and the session’s views in the list of views don’t all have the same recommended motion vector texture resolution excluding the secondary views, throw a NotSupportedError and abort these steps.
If session was not created with the "space-warp" feature descriptor and the session’s views in the list of views don’t all have the same recommended WebGL depth texture resolution excluding the secondary views, throw a NotSupportedError and abort these steps.
If layer’s layout is stereo-left-right, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context, textureFormat, stencil, numViews multiplied by width and height.
If layer’s layout is stereo-top-bottom, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context, textureFormat, stencil, width and numViews multiplied by height.
If the opaque texture was unable to be created for any reason, throw an OperationError and abort these steps.
return array.

To allocate motion vector textures for projection layers using an XRProjectionLayer layer, an XRTextureType textureType and a float scaleFactor, the user agent MUST run the following steps:

Let context be layer’s context.
Let array be a new array in the relevant realm of context.
Let session be layer’s session.
If session was not created with the "space-warp" feature descriptor, return array and abort these steps.
If context is a WebGLRenderingContext and the WEBGL_depth_texture extension is not enabled in context, return array and abort these steps.
let numViews be the number of the session’s list of views excluding the secondary views.
Let view be the first entry in the session’s list of views that is not a secondary view.
Let width be the width of view’s recommended motion vector texture resolution multiplied by scaleFactor.
Let height be the height of view’s recommended motion vector texture resolution multiplied by scaleFactor.
If layer’s layout is "mono" or "default":
If textureType is "texture-array":
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with numViews layers using context, RGBA16F, width and height.
If the opaque texture was unable to be created for any reason, throw an OperationError and abort these steps.
Return array and abort these steps.
Otherwise
For each view in the session’s list of views:
1. If view is a secondary view, continue.
2. Let width be the width of view’s recommended motion vector texture resolution multiplied by scaleFactor.
3. Let height be the height of view’s recommended motion vector texture resolution multiplied by scaleFactor.
4. let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context, RGBA16F, width and height.
5. If the texture was unable to be created for any reason, throw an OperationError and abort these steps.
6. Append texture to array.
Return array and abort these steps.
If the session’s views in the list of views don’t all have the same recommended motion vector texture resolution excluding the secondary views, throw a NotSupportedError and abort these steps.
If layer’s layout is stereo-left-right, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context, RGBA16F, numViews multiplied by width and height.
If layer’s layout is stereo-top-bottom, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context, RGBA16F, width and numViews multiplied by height.
If the opaque texture was unable to be created for any reason, throw an OperationError and abort these steps.
return array.

To allocate the color textures for the secondary views using an XRProjectionLayer layer, an XRTextureType textureType, a GLenum textureFormat and a float scaleFactor, the user agent MUST run the following steps:

Let context be layer’s context.
Let session be layer’s session.
Let array be a new array in the relevant realm of context.
If textureFormat is not in the list of color formats for projection layers, throw a NotSupportedError and abort these steps.
For each view in the session’s list of views:
1. If view is not a secondary view, continue.
2. Let width be the width of view’s recommended WebGL color texture resolution multiplied by scaleFactor.
3. Let height be the height of view’s recommended WebGL color texture resolution multiplied by scaleFactor.
4. Initialize texture as follows:
  
  If textureType is "texture-array":
  Let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with context, textureFormat, width and height.
  Otherwise
  Let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context, textureFormat, width and height.
5. If the texture was unable to be created for any reason, throw an OperationError and abort these steps.
6. Append texture to array.
Return array and abort these steps.

To allocate the depth textures for the secondary views using an XRProjectionLayer layer, an XRTextureType textureType, a GLenum textureFormat and a float scaleFactor, the user agent MUST run the following steps:

Let context be layer’s context.
Let session be layer’s session.
If textureFormat is 0, return array and abort these steps.
If context is a WebGLRenderingContext and the WEBGL_depth_texture extension is not enabled in context, return array and abort these steps.
If textureFormat is not in the list of depth formats for projection layers, throw a NotSupportedError and abort these steps.
Let array be a new array in the relevant realm of context.
For each view in the session’s list of views:
1. If view is not a secondary view, continue.
2. Let width be the width of view’s recommended WebGL depth texture resolution multiplied by scaleFactor.
3. Let height be the height of view’s recommended WebGL depth texture resolution multiplied by scaleFactor.
4. Initialize texture as follows:
  
  If textureType is "texture-array":
  Let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with context, textureFormat, stencil, width and height.
  Otherwise
  Let texture be a new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context, textureFormat, stencil, width and height.
5. Append texture to array.
Return array and abort these steps.

the scaleFactor needs to be recalculated for the secondary views.

To allocate color textures using an XRCompositionLayer layer, an XRTextureType textureType and an XRLayerInit init, the user agent MUST run the following steps:

let array be a new array in the relevant realm of context.
let context be layer’s context.
If init’s colorFormat is not in the list of color formats for non-projection layers, throw a NotSupportedError and abort these steps.
If init’s mipLevels is smaller than 1, throw a InvalidStateError and abort these steps.
If init’s mipLevels is larger than 1 and viewPixelWidth and viewPixelHeight are not powers of 2, throw a InvalidStateError and abort these steps
If layer’s layout is "mono":

If textureType is "texture-array":
Initialize array with 1 new instance of an opaque texture in the relevant realm of this context created as a TEXTURE_2D_ARRAY texture with 1 internal texture using context and init’s colorFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
Otherwise
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context and init’s colorFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
If layer’s layout is "stereo":

If textureType is "texture-array":
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with 2 layers using context and init’s colorFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
Return array and abort these steps.
Otherwise
Initialize array with 2 new instances of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context and init’s colorFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
Return array and abort these steps.
If layer’s layout is stereo-left-right, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context and init’s colorFormat, mipLevels, double of viewPixelWidth and viewPixelHeight values.
If layer’s layout is stereo-top-bottom, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context and init’s colorFormat, mipLevels, viewPixelWidth and double of viewPixelHeight values.
return array.

To allocate depth textures using an XRCompositionLayer layer, an XRTextureType textureType and an XRLayerInit init, the user agent MUST run the following steps:

let array be a new array in the relevant realm of context.
let context be layer’s context.
If init’s depthFormat is not set, return array and abort these steps.
If init’s depthFormat is not in the list of depth formats for non-projection layers, throw a NotSupportedError and abort these steps.
If init’s mipLevels is smaller than 1, throw a InvalidStateError and abort these steps.
If init’s mipLevels is larger than 1 and viewPixelWidth and viewPixelHeight are not powers of 2, throw a InvalidStateError and abort these steps.
If layer’s layout is "mono":

If textureType is "texture-array":
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with 1 internal texture using context and init’s depthFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
Otherwise
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context and init’s depthFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
If layer’s layout is "stereo":

If textureType is "texture-array":
Initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a TEXTURE_2D_ARRAY texture with 2 layers using context and init’s depthFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
Return array and abort these steps.
Otherwise
Initialize array with 2 new instances of an opaque texture in the relevant realm of context created as a TEXTURE_2D texture with context and init’s depthFormat, mipLevels, viewPixelWidth and viewPixelHeight values.
Return array and abort these steps.
If layer’s layout is stereo-left-right, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context and init’s depthFormat, mipLevels, double of viewPixelWidth and viewPixelHeight values.
If layer’s layout is stereo-top-bottom, initialize array with 1 new instance of an opaque texture in the relevant realm of context created as a textureType texture using context and init’s depthFormat, mipLevels, viewPixelWidth and double of viewPixelHeight values.
return array.

The createProjectionLayer(optional XRProjectionLayerInit init) method creates a new XRProjectionLayer layer.