Viewport: introduce a sub-container so that the viewport style is respected when going fullscreen

src/core/hud.ts

      * @param parent parent of the hud container
      * @param hudContainer an existing hud container (optional)
      */
-    constructor(parent: ViewportContainer, hudContainer: Nullable<HUDContainer>)
+    constructor(parent: HTMLElement, hudContainer: Nullable<HUDContainer>)
     {
         this._container = hudContainer || this._createContainer(parent);
         this._ownContainer = (hudContainer == null);
 
-        // validate
-        if(this._container.parentElement !== parent)
-            throw new IllegalArgumentError('The container of the HUD must be a direct child of the container of the viewport');
+        // move the HUD container to the parent node
+        if(this._container.parentElement !== parent) {
+            this._container.remove();
+            parent.insertAdjacentElement('afterbegin', this._container);
+        }
 
         // the HUD should be hidden initially
         if(!this._container.hidden)
         const node = document.createElement('div') as HTMLDivElement;
 
         node.hidden = true;
-        parent.appendChild(node);
+        parent.insertAdjacentElement('afterbegin', node);
 
         return node;
     }

src/core/viewport.ts

     /** Size of the drawing buffer of the background canvas @internal */
     readonly _realSize: SpeedySize;
 
+    /** Sub-container of the viewport container @internal */
+    readonly _subContainer: HTMLDivElement;
+
     /** Initialize the viewport @internal */
     _init(): void;
 
     /** Viewport container */
     container: Nullable<ViewportContainer>;
 
-    /** HUD container (must be a direct child of container) */
+    /** HUD container */
     hudContainer?: Nullable<HUDContainer>;
 
     /** Resolution of the canvas on which the virtual scene will be drawn */
     canvas: null,
 };
 
-/** Z-index of the viewport container */
+/** Z-index of the viewport container in immersive mode */
 const CONTAINER_ZINDEX = 1000000000;
 
 /** Base z-index of the children of the viewport container */
     /** Viewport style */
     protected _style: ViewportStyle;
 
+    /** A container inside the viewport container */
+    private readonly __subContainer: HTMLDivElement;
+
     /** Internal canvas used to render the physical scene */
     private readonly __backgroundCanvas: HTMLCanvasElement;
 
         // initialize attributes
         this._resolution = settings.resolution;
         this._container = settings.container;
-        this._hud = new HUD(settings.container, settings.hudContainer);
+        this.__subContainer = this._createSubContainer(this._container);
+        this._hud = new HUD(this.__subContainer, settings.hudContainer);
 
         // make this more elegant?
         // need to initialize this._style and validate settings.style
         this.style = settings.style;
 
         // create the background canvas
-        this.__backgroundCanvas = this._createBackgroundCanvas(this._container, size);
+        this.__backgroundCanvas = this._createBackgroundCanvas(this.__subContainer, size);
 
         // create the foreground canvas
         if(settings.canvas == null) {
-            this._foregroundCanvas = this._createForegroundCanvas(this._container, size);
+            this._foregroundCanvas = this._createForegroundCanvas(this.__subContainer, size);
             this._parentOfImportedForegroundCanvas = null;
         }
         else {
     }
 
     /**
+     * Sub-container of the viewport container
+     * @internal
+     */
+    get _subContainer(): HTMLDivElement
+    {
+        return this.__subContainer;
+    }
+
+    /**
      * Initialize the viewport (when the session starts)
      * @internal
      */
         // import foreground canvas
         if(this._parentOfImportedForegroundCanvas != null) {
             const size = Speedy.Size(DEFAULT_VIEWPORT_WIDTH, DEFAULT_VIEWPORT_HEIGHT);
-            this._importForegroundCanvas(this._foregroundCanvas, this._container, size);
+            this._importForegroundCanvas(this._foregroundCanvas, this._subContainer, size);
         }
 
         // setup CSS
         this._container.style.touchAction = 'none';
         this._container.style.backgroundColor = 'black';
-        this._container.style.zIndex = String(CONTAINER_ZINDEX);
 
         // initialize the HUD
         this._hud._init(HUD_ZINDEX);
     }
 
     /**
+     * Create a sub-container
+     * @param parent parent node
+     * @returns the canvas container
+     */
+    private _createSubContainer(parent: ViewportContainer): HTMLDivElement
+    {
+        const container = document.createElement('div') as HTMLDivElement;
+
+        container.style.position = 'absolute';
+        container.style.left = '0px';
+        container.style.top = '0px';
+        container.style.width = '100%';
+        container.style.height = '100%';
+
+        parent.appendChild(container);
+
+        return container;
+    }
+
+    /**
      * Create a canvas and attach it to another HTML element
      * @param parent parent container
      * @param size size of the drawing buffer
      * @param size size of the drawing buffer
      * @returns a new canvas as a child of parent
      */
-    private _createBackgroundCanvas(parent: ViewportContainer, size: SpeedySize): HTMLCanvasElement
+    private _createBackgroundCanvas(parent: HTMLElement, size: SpeedySize): HTMLCanvasElement
     {
         const canvas = this._createCanvas(parent, size);
         return this._styleCanvas(canvas, BACKGROUND_ZINDEX);
      * @param size size of the drawing buffer
      * @returns a new canvas as a child of parent
      */
-    private _createForegroundCanvas(parent: ViewportContainer, size: SpeedySize): HTMLCanvasElement
+    private _createForegroundCanvas(parent: HTMLElement, size: SpeedySize): HTMLCanvasElement
     {
         const canvas = this._createCanvas(parent, size);
         return this._styleCanvas(canvas, FOREGROUND_ZINDEX);
     }
 
     /**
+     * Sub-container of the viewport container
+     * @internal
+     */
+    get _subContainer(): HTMLDivElement
+    {
+        return this._base._subContainer;
+    }
+
+    /**
      * Initialize the viewport
      * @internal
      */
             window.addEventListener('orientationchange', this._resize.bind(this)); // deprecated
 
         // trigger a resize to setup the sizes / the CSS
-        this._resize();
+        // note: we may adjust this.style after this._init(); see the inline viewport
+        setTimeout(() => this._resize(), 0);
     }
 
     /**
 export class ImmersiveViewport extends ResizableViewport
 {
     /**
+     * Initialize the viewport
+     * @internal
+     */
+    _init(): void
+    {
+        const container = this.container;
+
+        container.style.position = 'fixed';
+        container.style.left = '0px';
+        container.style.top = '0px';
+        container.style.width = '100vw';
+        container.style.height = '100vh';
+        container.style.zIndex = String(CONTAINER_ZINDEX);
+
+        super._init();
+    }
+
+    /**
      * Release the viewport
      * @internal
      */
     {
         super._onResize();
 
-        const container = this.container;
-        container.style.position = 'fixed';
+        const container = this._subContainer;
+        container.style.position = 'absolute';
 
         if(this.style == 'best-fit') {
             // cover the page while maintaining the aspect ratio