RhinoRenderCycles.rhp

Plugin.cs

/**
Copyright 2014-2017 Robert McNeel and Associates

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
**/

using System;
using System.Drawing;
using Rhino;
using Rhino.Commands;
using Rhino.Display;
using Rhino.DocObjects;
using Rhino.PlugIns;
using Rhino.Render;
using RhinoCyclesCore.RenderEngines;

namespace CyclesForRhino.CyclesForRhino
{
  public class Plugin : RenderPlugIn
  {
    public override PlugInLoadTime LoadTime => PlugInLoadTime.AtStartup;

    protected override bool SupportsFeature(RenderFeature feature)
    {
      if (feature == RenderFeature.CustomDecalProperties)
        return false;

      return true;
    }

    protected override Result RenderWindow(RhinoDoc doc, RunMode modes, bool fastPreview, RhinoView view, Rectangle rect, bool inWindow)
    {
      return Result.Failure;
    }

    protected override PreviewRenderTypes PreviewRenderType()
    {
      return PreviewRenderTypes.Progressive;
    }

    /// <summary>
    /// Implement the render entry point.
    /// 
    /// Rhino data is prepared for further conversion in RenderEngine.
    /// </summary>
    /// <param name="doc">Rhino document for which the render command was given</param>
    /// <param name="mode">mode</param>
    /// <param name="fastPreview">True for fast preview.</param>
    /// <returns></returns>
    protected override Result Render(RhinoDoc doc, RunMode mode, bool fastPreview)
    {
      Rectangle fullSize = new Rectangle(new Point(0, 0), RenderPipeline.RenderSize(doc, true));
      return RenderWithCycles(doc, mode, fullSize, true);
    }

    protected override Result RenderWindow(RhinoDoc doc, RunMode mode, bool fastPreview, RhinoView view, Rectangle rect, bool inWindow, bool blowup)
    {
      return RenderWithCycles(doc, mode, rect, inWindow);
    }

    private Result RenderWithCycles(RhinoDoc doc, RunMode mode, Rectangle rect, bool inWindow)
    {
      var rc = RenderPipeline.RenderReturnCode.InternalError;
      using (var rsv = new RenderSourceView(doc))
      {
        {
          foreach (var vw in doc.Views)
          {
            try
            {
              vw.RealtimeDisplayMode.Paused = true;
            }
            catch (Exception)
            {
              // pass
            }
          }
        }
        ViewInfo vi = rsv.GetViewInfo();
        var renderSize = new Size(rect.Width, rect.Height);
        var fullSize = inWindow ? renderSize : vi.Viewport.GetScreenPort().Size;
        ModalRenderEngine engine = new ModalRenderEngine(doc, Id, vi, true)
        {
          BufferRectangle = rect,
          FullSize = fullSize
        };

        var pipe = new RhinoCycles.RenderPipeline(doc, mode, this, renderSize, engine);

        engine.RenderWindow = pipe.GetRenderWindow(true, false);
        engine.RenderWindow.SetSize(renderSize);

        bool rwrc = engine.RenderWindow.AddChannel(Rhino.Render.RenderWindow.StandardChannels.DistanceFromCamera);
        System.Diagnostics.Debug.Assert(rwrc);
        rwrc = engine.RenderWindow.AddChannel(Rhino.Render.RenderWindow.StandardChannels.NormalXYZ);
        System.Diagnostics.Debug.Assert(rwrc);

        engine.RenderDimension = renderSize;
        engine.Database.RenderDimension = renderSize;

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

        if (inWindow)
          rc = pipe.Render();
        else
          rc = pipe.RenderWindow(doc.Views.ActiveView, rect, inWindow);
      }

      if (Rhino.Render.RenderPipeline.RenderReturnCode.Ok != rc)
      {
        RhinoApp.WriteLine("Render setup failed:" + rc.ToString());
        return Result.Failure;
      }

      return Result.Success;
    }

    /// <summary>
    /// Handler for rendering preview thumbnails.
    /// 
    /// The CreatePreviewEventArgs parameter contains a simple
    /// scene description to be rendered. It contains a set of meshes
    /// and lights. Meshes have RenderMaterials attached to them.
    /// </summary>
    /// <param name="scene">The scene description to render, along with the requested quality setting</param>
    protected override void CreatePreview(CreatePreviewEventArgs scene)
    {
      scene.SkipInitialisation();

      if (scene.Quality == PreviewSceneQuality.Low)
      {
        scene.PreviewImage = null;
        return;
      }

      var engine = new PreviewRenderEngine(scene, Id)
      {
        BufferRectangle = new Rectangle(new Point(0, 0), scene.PreviewImageSize),
        FullSize = scene.PreviewImageSize
      };

      engine.RenderDimension = scene.PreviewImageSize;
      /* create a window-less, non-document controlled render window */
      engine.RenderWindow = Rhino.Render.RenderWindow.Create(scene.PreviewImageSize);
      engine.Database.RenderDimension = engine.RenderDimension;

      engine.CreateWorld();

      /* render the preview scene */
      PreviewRenderEngine.Renderer(engine);

      /* set final preview bitmap, or null if cancelled */
      scene.PreviewImage = engine.RenderWindow.GetBitmap();

      engine.RenderWindow.Dispose();
    }
  }
}