setPlaneRenderOrder(plane) {
        if(plane.type === "ShaderPass") {
            this.sortShaderPassStack(plane._isScenePass ? this.stacks.scenePasses : this.stacks.renderPasses);
        }
        else if(plane.type === "PingPongPlane") {
            // this does not makes any sense for ping pong planes
            return;
        }

        if(plane.target) {
            // sort by index (order of addition) then render order, depending on whether the render target handle depth or not
            if(plane.target._depth) {
                this.stacks.renderTargets.sort((a, b) => a.index - b.index);
                this.stacks.renderTargets.sort((a, b) => b.renderOrder - a.renderOrder);
            }
            else {
                this.stacks.renderTargets.sort((a, b) => b.index - a.index);
                this.stacks.renderTargets.sort((a, b) => a.renderOrder - b.renderOrder);
            }

            // then sort by render targets order
            this.stacks.renderTargets.sort((a, b) => a.target.index - b.target.index);
        }
        else {
            const planeStack = plane._transparent ?
                this.stacks.transparent
                : this.stacks.opaque;

            // if the first drawn scene pass does not handle depth, we'll have to sort them in the inverse order
            const scenePassWithoutDepth = this.stacks.scenePasses.find((pass, index) => pass._isScenePass && !pass._depth && index === 0);

            if(!this.renderer.depth || scenePassWithoutDepth) {
                // inverted sorting

                // sort by indexes
                planeStack.sort((a, b) => b.index - a.index);

                if(plane._transparent) {
                    // if plane is transparent, sort by their depth position
                    planeStack.sort((a, b) => a.relativeTranslation.z - b.relativeTranslation.z);
                }

                // then sort by render order
                planeStack.sort((a, b) => a.renderOrder - b.renderOrder);
            }
            else {
                // regular sorting

                // sort by indexes
                planeStack.sort((a, b) => a.index - b.index);

                if(plane._transparent) {
                    // if plane is transparent, sort by their depth position
                    planeStack.sort((a, b) => b.relativeTranslation.z - a.relativeTranslation.z);
                }

                // then sort by render order
                planeStack.sort((a, b) => b.renderOrder - a.renderOrder);
            }
        }
    }
Changing the position of a plane inside the correct plane stack to render it on above or behind the other planes

     params:
     @plane (Plane object): the plane that had its renderOrder property updated
*