constructor(renderer, htmlElement, {
        // Mesh params
        widthSegments,
        heightSegments,
        renderOrder,
        depthTest,
        cullFace,
        uniforms,
        vertexShaderID,
        fragmentShaderID,
        vertexShader,
        fragmentShader,
        texturesOptions,
        crossOrigin,

        // Plane specific params
        alwaysDraw = false,
        visible = true,
        transparent = false,
        drawCheckMargins = {
            top: 0,
            right: 0,
            bottom: 0,
            left: 0,
        },
        autoloadSources = true,
        watchScroll = true,
        fov = 50,
    } = {}) {
        super(renderer, htmlElement, "Plane", {
            widthSegments,
            heightSegments,
            renderOrder,
            depthTest,
            cullFace,
            uniforms,
            vertexShaderID,
            fragmentShaderID,
            vertexShader,
            fragmentShader,
            texturesOptions,
            crossOrigin,
        });

        // return if no gl context
        if(!this.gl) {
            return;
        }

        this.index = this.renderer.planes.length;

        // used for FBOs
        this.target = null;

        // use frustum culling or not
        this.alwaysDraw = alwaysDraw;
        // should draw is set to true by default, we'll check it later
        this._shouldDraw = true;

        this.visible = visible;

        // if the plane has transparency
        this._transparent = transparent;

        // draw check margins in pixels
        // positive numbers means it can be displayed even when outside the viewport
        // negative numbers means it can be hidden even when inside the viewport
        this.drawCheckMargins = drawCheckMargins;

        // if we decide to load all sources on init or let the user do it manually
        this.autoloadSources = autoloadSources;

        // if we should watch scroll
        this.watchScroll = watchScroll;

        // define if we should update the plane's matrices when called in the draw loop
        this._updateMVMatrix = false;

        // init camera
        this.camera = new Camera({
            fov: fov,
            width: this.renderer._boundingRect.width,
            height: this.renderer._boundingRect.height,
            pixelRatio: this.renderer.pixelRatio,
        });

        // if program is valid, go on
        if(this._program.compiled) {
            // init our plane
            this._initPlane();

            // add our plane to the scene stack and the renderer array
            this.renderer.scene.addPlane(this);
            this.renderer.planes.push(this);
        }
    }
Here we create our Plane object
 We will extend our DOMMesh class that handles all the WebGL part and basic HTML sizings

 Plane class will add:
 - sizing and positioning and everything that relates to the DOM like draw checks (frustum culling) and reenter/leave events
 - projection (using Camera class object) and view matrices and everything that is related like perspective, scale, rotation...

 params :
 @renderer (Curtains renderer or Renderer class object): our curtains object OR our curtains renderer object
 @plane (html element): the html element that we will use for our Plane object

 @Meshparams (object): see Mesh class object

 @alwaysDraw (boolean, optionnal): if the plane should always be drawn or if it should use frustum culling. Default to false.
 @visible (boolean, optional): if the plane should be drawn or not. Default to true.
 @transparent (boolean, optional): if the plane should handle transparency. Default to false.
 @drawCheckMargins (object, optional): defines the margins in pixels to add to the frustum culling check to determine if the plane should be drawn. Default to 0.
 @autoloadSources (boolean, optional): if the sources should be loaded on init automatically. Default to true
 @watchScroll (boolean, optional): if the plane should auto update its position based on the scroll value. Default to true.
 @fov (float, optional): defines the perspective field of view used by the camera. Default to 50.

 returns :
 @this: our Plane
*