public override bool StartRenderer(int w, int h, RhinoDoc doc, ViewInfo rhinoView, ViewportInfo viewportInfo, bool forCapture, RenderWindow renderWindow)
        {
            _started     = true;
            _forCapture  = forCapture;
            _useFastDraw = UseFastDraw();
            if (forCapture)
            {
                SetUseDrawOpenGl(false);
                _useFastDraw = UseFastDraw();
                var mre = new ModalRenderEngine(doc, PlugIn.IdFromName("RhinoCycles"), rhinoView, viewportInfo, Dpa);
                mre.SetCallbackForCapture();

                _cycles = null;
                _modal  = mre;

                var rs = new Size(w, h);

                mre.RenderWindow = renderWindow;

                mre.RenderDimension          = rs;
                mre.Database.RenderDimension = rs;

                mre.StatusTextUpdated += Mre_StatusTextUpdated;

                mre.Database.LinearWorkflowChanged += DatabaseLinearWorkflowChanged;

                mre.CreateWorld();                 // has to be done on main thread, so lets do this just before starting render session

                _modalThread = new Thread(RenderOffscreen)
                {
                    Name = $"Cycles offscreen viewport rendering with ModalRenderEngine {_serial}"
                };
                _modalThread.Start(mre);

                return(true);
            }
            _fadeInMs = RcCore.It.EngineSettings.FadeInMs;

            _frameAvailable = false;
            _sameView       = false;

            _cycles = new ViewportRenderEngine(doc.RuntimeSerialNumber, PlugIn.IdFromName("RhinoCycles"), rhinoView, Dpa);

            _cycles.StatusTextUpdated              += CyclesStatusTextUpdated; // render engine tells us status texts for the hud
            _cycles.RenderStarted                  += CyclesRenderStarted;     // render engine tells us when it actually is rendering
            _cycles.StartSynchronizing             += CyclesStartSynchronizing;
            _cycles.Synchronized                   += CyclesSynchronized;
            _cycles.PassRendered                   += CyclesPassRendered;
            _cycles.Database.LinearWorkflowChanged += DatabaseLinearWorkflowChanged;
            _cycles.UploadProgress                 += _cycles_UploadProgress;

            ViewportSettingsChanged += _cycles.ViewportSettingsChangedHandler;
            _cycles.CurrentViewportSettingsRequested += _cycles_CurrentViewportSettingsRequested;
            var renderSize = Rhino.Render.RenderPipeline.RenderSize(doc);

            _cycles.RenderWindow    = renderWindow;
            _cycles.RenderDimension = renderSize;

            _maxSamples = RcCore.It.EngineSettings.Samples;

            _startTime = DateTime.UtcNow;      // use _startTime to time CreateWorld
            _cycles.CreateWorld();             // has to be done on main thread, so lets do this just before starting render session

            var createWorldDuration = DateTime.UtcNow - _startTime;

            RhinoApp.OutputDebugString($"CreateWorld({RcCore.It.EngineSettings.FlushAtEndOfCreateWorld}): {createWorldDuration.Ticks} ticks ({createWorldDuration.TotalMilliseconds} ms)\n");

            _startTime = DateTime.UtcNow;
            _lastTime  = _startTime;
            if (_useFastDraw)
            {
                _sw = new Thread(TimerForAlpha)
                {
                    Name = "Cycles RenderedViewport Alpha Thread"
                };
                _sw.Start();
            }
            _cycles.StartRenderThread(_cycles.Renderer, $"A cool Cycles viewport rendering thread {_serial}");

            return(true);
        }