function Plane(renderer, htmlElement) {
      var _this31;

      var _ref11 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
          widthSegments = _ref11.widthSegments,
          heightSegments = _ref11.heightSegments,
          renderOrder = _ref11.renderOrder,
          depthTest = _ref11.depthTest,
          cullFace = _ref11.cullFace,
          uniforms = _ref11.uniforms,
          vertexShaderID = _ref11.vertexShaderID,
          fragmentShaderID = _ref11.fragmentShaderID,
          vertexShader = _ref11.vertexShader,
          fragmentShader = _ref11.fragmentShader,
          texturesOptions = _ref11.texturesOptions,
          crossOrigin = _ref11.crossOrigin,
          _ref11$alwaysDraw = _ref11.alwaysDraw,
          alwaysDraw = _ref11$alwaysDraw === void 0 ? false : _ref11$alwaysDraw,
          _ref11$visible = _ref11.visible,
          visible = _ref11$visible === void 0 ? true : _ref11$visible,
          _ref11$transparent = _ref11.transparent,
          transparent = _ref11$transparent === void 0 ? false : _ref11$transparent,
          _ref11$drawCheckMargi = _ref11.drawCheckMargins,
          drawCheckMargins = _ref11$drawCheckMargi === void 0 ? {
        top: 0,
        right: 0,
        bottom: 0,
        left: 0
      } : _ref11$drawCheckMargi,
          _ref11$autoloadSource = _ref11.autoloadSources,
          autoloadSources = _ref11$autoloadSource === void 0 ? true : _ref11$autoloadSource,
          _ref11$watchScroll = _ref11.watchScroll,
          watchScroll = _ref11$watchScroll === void 0 ? true : _ref11$watchScroll,
          _ref11$fov = _ref11.fov,
          fov = _ref11$fov === void 0 ? 50 : _ref11$fov;

      _classCallCheck(this, Plane);

      _this31 = _super3.call(this, renderer, htmlElement, "Plane", {
        widthSegments: widthSegments,
        heightSegments: heightSegments,
        renderOrder: renderOrder,
        depthTest: depthTest,
        cullFace: cullFace,
        uniforms: uniforms,
        vertexShaderID: vertexShaderID,
        fragmentShaderID: fragmentShaderID,
        vertexShader: vertexShader,
        fragmentShader: fragmentShader,
        texturesOptions: texturesOptions,
        crossOrigin: crossOrigin
      }); // return if no gl context

      if (!_this31.gl) {
        return _possibleConstructorReturn(_this31);
      }

      _this31.index = _this31.renderer.planes.length; // used for FBOs

      _this31.target = null; // use frustum culling or not

      _this31.alwaysDraw = alwaysDraw; // should draw is set to true by default, we'll check it later

      _this31._shouldDraw = true;
      _this31.visible = visible; // if the plane has transparency

      _this31._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

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

      _this31.autoloadSources = autoloadSources; // if we should watch scroll

      _this31.watchScroll = watchScroll; // define if we should update the plane's matrices when called in the draw loop

      _this31._updateMVMatrix = false; // init camera

      _this31.camera = new Camera({
        fov: fov,
        width: _this31.renderer._boundingRect.width,
        height: _this31.renderer._boundingRect.height,
        pixelRatio: _this31.renderer.pixelRatio
      }); // if program is valid, go on

      if (_this31._program.compiled) {
        // init our plane
        _this31._initPlane(); // add our plane to the scene stack and the renderer array


        _this31.renderer.scene.addPlane(_assertThisInitialized(_this31));

        _this31.renderer.planes.push(_assertThisInitialized(_this31));
      }

      return _this31;
    }
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
*