setSession method

Future<void> setSession(XRSession? value)

After a XR session has been requested usually with one of the *Button modules, it is injected into the renderer with this method. This method triggers the start of the actual XR rendering.

@async @param {XRSession} value - The XR session to set. return Future A Promise that resolves when the session has been set. /

Implementation

Future<void> setSession(XRSession? value ) async{
  session = value;

  if ( session != null ) {
    initialRenderTarget = renderer.getRenderTarget();

    session?.addEventListener( 'select', onSessionEvent.jsify() );
    session?.addEventListener( 'selectstart', onSessionEvent.jsify() );
    session?.addEventListener( 'selectend', onSessionEvent.jsify() );
    session?.addEventListener( 'squeeze', onSessionEvent.jsify() );
    session?.addEventListener( 'squeezestart', onSessionEvent.jsify() );
    session?.addEventListener( 'squeezeend', onSessionEvent.jsify() );
    session?.addEventListener( 'end', onSessionEnd.jsify() );
    session?.addEventListener( 'inputsourceschange', onInputSourcesChange.jsify() );

    if ( attributes['xrCompatible'] != true ) {
      await gl.makeXRCompatible();
    }

    currentPixelRatio = renderer.getPixelRatio();
    renderer.getSize( currentSize );

    // Check that the browser implements the necessary APIs to use an
    // XRProjectionLayer rather than an XRWebGLLayer
    final useLayers = session?.renderState.layers != null;//typeof XRWebGLBinding != 'null' && 'createProjectionLayer' in XRWebGLBinding.prototype;

    if (!useLayers) {
      final layerInit = {
        'antialias': attributes['antialias'],
        'alpha': attributes['alpha'],
        'depth': attributes['depth'],
        'stencil': attributes['stencil'],
        'framebufferScaleFactor': framebufferScaleFactor
      };

      glBaseLayer = XRWebGLLayer( session!, gl.gl.gl, layerInit.jsify() );
      session?.updateRenderState( { 'baseLayer': glBaseLayer }.jsify() );
      renderer.setPixelRatio( 1 );
      renderer.setSize( glBaseLayer!.framebufferWidth.toDouble(), glBaseLayer!.framebufferHeight.toDouble(), false );

      newRenderTarget = WebGLRenderTarget(
        glBaseLayer!.framebufferWidth,
        glBaseLayer!.framebufferHeight,
        WebGLRenderTargetOptions({
          'format': RGBFormat,
          'type': UnsignedByteType,
          'colorSpace': renderer.outputColorSpace,
          'stencilBuffer': attributes['stencil'],
          'resolveDepthBuffer': ( glBaseLayer?.ignoreDepthValues == false ),
          'resolveStencilBuffer': ( glBaseLayer?.ignoreDepthValues == false )
        })
      );
    }
    else {
      int? depthFormat;
      int? depthType;
      int? glDepthFormat;

      if ( attributes['depth'] ) {
        glDepthFormat = attributes['stencil'] ? WebGL.DEPTH24_STENCIL8 : WebGL.DEPTH_COMPONENT24;
        depthFormat = attributes['stencil'] ? DepthStencilFormat : DepthFormat;
        depthType = attributes['stencil'] ? UnsignedInt248Type : UnsignedIntType;
      }

      final projectionlayerInit = {
        'colorFormat': WebGL.RGBA8,
        'depthFormat': glDepthFormat,
        'scaleFactor': framebufferScaleFactor
      };

      glBinding = XRWebGLBinding( session!, gl.gl.gl );

      glProjLayer = glBinding?.createProjectionLayer( projectionlayerInit.jsify() );

      session?.updateRenderState( { 'layers': [ glProjLayer ] }.jsify() );

      renderer.setPixelRatio( 1 );
      renderer.setSize( glProjLayer!.textureWidth.toDouble(), glProjLayer!.textureHeight.toDouble(), false );

      newRenderTarget = WebGLRenderTarget(
        glProjLayer!.textureWidth,
        glProjLayer!.textureHeight,
        WebGLRenderTargetOptions({
          'format': RGBAFormat,
          'type': UnsignedByteType,
          'depthTexture': DepthTexture( glProjLayer!.textureWidth, glProjLayer!.textureHeight, depthType, null, null, null, null, null, null, depthFormat ),
          'stencilBuffer': attributes['stencil'],
          'colorSpace': renderer.outputColorSpace,
          'samples': attributes['antialias'] ? 4 : 0,
          'resolveDepthBuffer': ( glProjLayer?.ignoreDepthValues == false ),
          'resolveStencilBuffer': ( glProjLayer?.ignoreDepthValues == false )
        })
      );
    }

    newRenderTarget?.isXRRenderTarget = true;
    setFoveation( foveation  );
    customReferenceSpace = null;
    referenceSpace = (await (session?.requestReferenceSpace( referenceSpaceType ).toDart)) as XRReferenceSpace;

    animation.setContext( session );
    animation.start();

    isPresenting = true;
    dispatchEvent( Event(type: 'sessionstart' ) );
  }
}