/// <summary>
/// Convert a Rhino.Render.ChangeQueue.Light to a CyclesLight
/// </summary>
/// <param name="changequeue"></param>
/// <param name="light"></param>
/// <param name="view"></param>
/// <param name="gamma"></param>
/// <returns></returns>
internal CyclesLight ConvertLight(ChangeQueue changequeue, Light light, ViewInfo view, float gamma)
{
if (changequeue != null && view != null)
{
if (light.Data.LightStyle == LightStyle.CameraDirectional)
{
ChangeQueue.ConvertCameraBasedLightToWorld(changequeue, light, view);
}
}
var cl = ConvertLight(light.Data, gamma);
cl.Id = light.Id;
if (light.ChangeType == Light.Event.Deleted)
{
cl.Strength = 0;
}
return cl;
}
public ViewportRenderEngine(uint docRuntimeSerialNumber, Guid pluginId, ViewInfo view)
: base(pluginId, docRuntimeSerialNumber, view, null, true)
{
Client = new Client();
State = State.Rendering;
Database.ViewChanged += Database_ViewChanged;
ChangesReady += ViewportRenderEngine_ChangesReady;
#region create callbacks for Cycles
m_update_callback = UpdateCallback;
m_update_render_tile_callback = null;
m_write_render_tile_callback = null;
m_test_cancel_callback = null;
m_display_update_callback = DisplayUpdateHandler;
CSycles.log_to_stdout(false);
#endregion
}
public void HandleWallpaper(ViewInfo view, bool scaleToFit)
{
modified |= m_old_hidden != view.WallpaperHidden | m_old_grayscale != view.ShowWallpaperInGrayScale;
modified |= m_old_scaletofit != scaleToFit;
modified |= !m_old_wallpaper.Equals(view.WallpaperFilename);
m_old_hidden = view.WallpaperHidden;
m_old_grayscale = view.ShowWallpaperInGrayScale;
m_old_scaletofit = scaleToFit;
if (string.IsNullOrEmpty(view.WallpaperFilename) || !File.Exists(view.WallpaperFilename))
{
wallpaper.Clear();
return;
}
m_old_wallpaper = view.WallpaperFilename ?? "";
var crc = Rhino.RhinoMath.CRC32(27, System.Text.Encoding.UTF8.GetBytes(m_old_wallpaper));
try
{
int near, far;
var screenport = view.Viewport.GetScreenPort(out near, out far);
var bottom = screenport.Bottom;
var top = screenport.Top;
var left = screenport.Left;
var right = screenport.Right;
// color matrix used for conversion to gray scale
ColorMatrix cm = new ColorMatrix(
new[]{
new[] { 0.3f, 0.3f, 0.3f, 0.0f, 0.0f},
new[] { .59f, .59f, .59f, 0.0f, 0.0f},
new[] { .11f, .11f, .11f, 0.0f, 0.0f},
new[] { 0.0f, 0.0f, 0.0f, 1.0f, 0.0f},
new[] { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}
}
);
ImageAttributes attr = new ImageAttributes();
attr.SetColorMatrix(cm);
var w = Math.Abs(right - left);
var h = Math.Abs(bottom - top);
Bitmap bm = new Bitmap(view.WallpaperFilename);
var ar = (float) bm.Width/bm.Height;
var fac = 1.0f;
if (ar < 1.0f)
{
fac = (h/(float)bm.Height);
}
else if (ar > 1.0f)
{
fac = (w/(float)bm.Width);
}
int nw = (int)(bm.Width * fac);
int nh = (int)(bm.Height * fac);
int x = (w - nw)/2;
int y = (h - nh)/2;
Bitmap newBitmap = new Bitmap(w, h);
var col = Color.Aqua;
if (color1 != Color.Empty) col = color1;
var brush = new SolidBrush(col);
var p = new Point(x, y);
var bmsize= new Size(nw,nh);
if (scaleToFit)
{
bmsize = new Size(w, h);
p = new Point(0, 0);
}
using (Graphics g = Graphics.FromImage(newBitmap))
{
g.FillRectangle(brush, new Rectangle(Point.Empty, newBitmap.Size));
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
if (!view.WallpaperHidden)
{
if (view.ShowWallpaperInGrayScale)
{
g.DrawImage(bm, new Rectangle(p, bmsize), 0, 0, bm.Width, bm.Height, GraphicsUnit.Pixel, attr);
}
else
{
g.DrawImage(bm, new Rectangle(p, bmsize));
}
}
}
var wallpaperbm = BitmapConverter.ReadByteBitmapFromBitmap(crc, newBitmap.Size.Width, newBitmap.Size.Height, newBitmap);
wallpaperbm.ApplyGamma(Gamma);
wallpaper.TexByte = wallpaperbm.Corrected;
if(RcCore.It.EngineSettings.SaveDebugImages) wallpaperbm.SaveBitmaps();
wallpaper.TexWidth = newBitmap.Width;
wallpaper.TexHeight = newBitmap.Height;
wallpaper.Name =
$"{view.WallpaperFilename}_{newBitmap.Width}x{newBitmap.Height}_{view.WallpaperHidden}_{view.ShowWallpaperInGrayScale}_{scaleToFit}_{id}";
}
catch (Exception)
{
wallpaper.Clear();
}
}
/// <summary>
/// Same as <see cref="HandleWallpaper(ViewInfo, bool)"/>, but re-use old scaletofit setting
/// </summary>
/// <param name="view"></param>
public void HandleWallpaper(ViewInfo view)
{
HandleWallpaper(view, m_old_scaletofit);
}
/// <summary>
/// Sets the DefaultView given the boundingBox and the viewInfo
/// </summary>
public virtual void GetDefaultView (BoundingBox bbox, ref ViewInfo view) {
// simple parallel projection of bounding box;
const double window_height = 1.0;
const double window_width = 1.0;
double dx, dy, dz;
double frus_near, frus_far;
Point3d camLoc;
Vector3d camDir, camUp;
view.Viewport.TargetPoint = 0.5*(bbox.Min + bbox.Max);
dx = 1.1*(bbox.Max[0] - bbox.Min[0]);
dy = 1.1*(bbox.Max[1] - bbox.Min[1]);
dz = 1.1*(bbox.Max[2] - bbox.Min[2]);
if ( dx <= 1.0e-6 && dy <= 1.0e-6 )
dx = dy = 2.0;
if ( window_height*dx < window_width*dy ) {
dx = dy*window_width/window_height;
}
else {
dy = dx*window_height/window_width;
}
if ( dz <= 0.1*(dx+dy) )
dz = 0.1*(dx+dy);
dx *= 0.5;
dy *= 0.5;
dz *= 0.5;
frus_near = 1.0;
frus_far = frus_near + 2.0*dz;
camLoc = view.Viewport.TargetPoint + (dz + frus_near)*Vector3d.ZAxis;
camDir = new Vector3f(0, 0, -1);
camUp = Vector3f.YAxis;
view.Viewport.ChangeToParallelProjection (false);
view.Viewport.SetCameraLocation (camLoc);
view.Viewport.SetCameraDirection (camDir);
view.Viewport.SetCameraUp (camUp);
view.Viewport.SetFrustum ( -dx, dx, -dy, dy, frus_near, frus_far );
}
/// <summary>
/// Prepare the Viewports in the ModelFile
/// </summary>
protected virtual void PrepareViewports()
{
if (ModelFile != null) {
// Initialize DefaultView from model
bool initialized = false;
int view_count = ModelFile.Views.Count;
if (view_count > 0) {
// find first perspective viewport projection in file
foreach (var view in ModelFile.Views) {
if (view.Viewport.IsPerspectiveProjection) {
initialized = true;
DefaultView = view;
DefaultView.Viewport.TargetPoint = view.Viewport.TargetPoint;
DefaultView.Name = view.Name;
break;
}
}
}
// If there were no perspective views, make one...
if (!initialized) {
try{
if (ModelFile.Views.ElementAtOrDefault(0) != null) {
DefaultView = ModelFile.Views [0];
GetDefaultView (BBox, ref m_defaultView);
} else {
DefaultView = new ViewInfo(ModelFile, new Guid(), IntPtr.Zero, false);
GetDefaultView (BBox, ref m_defaultView);
}
} catch (Exception ex) {
Rhino.Runtime.HostUtils.ExceptionReport (ex);
}
}
// fix up viewport values
Rhino.Geometry.Vector3d camDir = DefaultView.Viewport.CameraDirection;
camDir.Unitize ();
DefaultView.Viewport.SetCameraDirection (camDir);
Rhino.Geometry.Vector3d camUp = DefaultView.Viewport.CameraUp;
camUp.Unitize ();
DefaultView.Viewport.SetCameraUp (camUp);
}
}
public void DisposeOfModelData ()
{
if (ModelFile != null) {
ModelFile.Dispose ();
ModelFile = null;
}
if (DisplayObjects != null) {
foreach (var displayObject in DisplayObjects)
displayObject.Dispose ();
DisplayObjects.Clear ();
DisplayObjects = null;
}
if (DisplayMeshes != null) {
foreach (var displayMesh in DisplayMeshes)
displayMesh.Dispose ();
DisplayMeshes.Clear ();
DisplayMeshes = null;
}
if (DisplayInstanceMeshes != null) {
foreach (var displayInstanceMesh in DisplayInstanceMeshes)
displayInstanceMesh.Dispose ();
DisplayInstanceMeshes.Clear ();
DisplayInstanceMeshes = null;
}
if (TransparentObjects != null) {
foreach (var displayMesh in TransparentObjects)
displayMesh.Dispose ();
TransparentObjects.Clear ();
TransparentObjects = null;
}
if (TransparentInstanceObjects != null) {
foreach (var displayInstanceMesh in TransparentInstanceObjects)
displayInstanceMesh.Dispose ();
TransparentInstanceObjects.Clear ();
TransparentInstanceObjects = null;
}
if (ModelObjectsDictionary != null) {
ModelObjectsDictionary.Clear ();
ModelObjectsDictionary = null;
}
if (ModelObjects != null) {
ModelObjects.Clear ();
ModelObjects = null;
}
if (DefaultView != null) {
DefaultView.Dispose ();
DefaultView = null;
}
if (AllMeshes != null) {
AllMeshes.Clear ();
AllMeshes = null;
}
if (Layers != null) {
Layers.Clear ();
Layers = null;
}
if (LayersWithGeometry != null) {
LayersWithGeometry.Clear ();
LayersWithGeometry = null;
}
if (LayerBBoxes != null) {
LayerBBoxes.Clear ();
LayerBBoxes = null;
}
VisibleLayersBBox = BoundingBox.Empty;
BBox = BoundingBox.Empty;
m_visibleLayersBoundingBox = BoundingBox.Empty;
m_bBox = BoundingBox.Empty;
m_meshPrepProgress = null;
IsReadyForRendering = false;
}
public void BackgroundWallpaper(ViewInfo view)
{
_cqBackground.HandleWallpaper(view);
}
/// <summary>
/// Reset changequeue lists and dictionaries. Generally this is done once all changes
/// have been handled, and thus no longer needed.
/// </summary>
public void ResetChangeQueue()
{
_dynamic = false;
_currentViewInfo = null;
ClearLinearWorkflow();
_environmentDatabase.ResetBackgroundChangeQueue();
_cameraDatabase.ResetViewChangeQueue();
_lightDatabase.ResetLightChangeQueue();
_shaderDatabase.ClearShaders();
_shaderDatabase.ClearObjectShaderChanges();
_objectDatabase.ResetObjectsChangeQueue();
_objectDatabase.ResetMeshChangeQueue();
_objectDatabase.ResetDynamicObjectTransformChangeQueue();
}
public override bool StartRenderer(int w, int h, RhinoDoc doc, ViewInfo rhinoView, ViewportInfo viewportInfo, bool forCapture, RenderWindow renderWindow)
{
_started = true;
if (forCapture)
{
ModalRenderEngine mre = new ModalRenderEngine(doc, PlugIn.IdFromName("RhinoCycles"), rhinoView, viewportInfo);
_cycles = null;
_modal = mre;
mre.Settings = RcCore.It.EngineSettings;
mre.Settings.UseInteractiveRenderer = false;
mre.Settings.SetQuality(doc.RenderSettings.AntialiasLevel);
var rs = new Size(w, h);
mre.RenderWindow = renderWindow;
mre.RenderDimension = rs;
mre.Database.RenderDimension = rs;
mre.Settings.Verbose = true;
mre.StatusTextUpdated += Mre_StatusTextUpdated;
mre.Database.LinearWorkflowChanged += DatabaseLinearWorkflowChanged;
mre.SetFloatTextureAsByteTexture(false); // mre.Settings.RenderDeviceIsOpenCl);
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;
}
_available = false; // the renderer hasn't started yet. It'll tell us when it has.
_frameAvailable = false;
_cycles = new ViewportRenderEngine(doc.RuntimeSerialNumber, PlugIn.IdFromName("RhinoCycles"), rhinoView);
_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.SamplesChanged += CyclesSamplesChanged;
_cycles.Settings = RcCore.It.EngineSettings;
_cycles.Settings.SetQuality(doc.RenderSettings.AntialiasLevel);
var renderSize = Rhino.Render.RenderPipeline.RenderSize(doc);
_cycles.RenderWindow = renderWindow;
_cycles.RenderDimension = renderSize;
_cycles.Settings.Verbose = true;
_maxSamples = _cycles.Settings.Samples;
_cycles.SetFloatTextureAsByteTexture(false); // m_cycles.Settings.RenderDeviceIsOpenCl);
_cycles.CreateWorld(); // has to be done on main thread, so lets do this just before starting render session
_startTime = DateTime.UtcNow;
_cycles.StartRenderThread(_cycles.Renderer, $"A cool Cycles viewport rendering thread {_serial}");
return true;
}
public override bool IsFrameBufferAvailable(ViewInfo view)
{
if (_cycles != null)
{
var equal = _cycles.Database.AreViewsEqual(GetView(), view);
return equal && _frameAvailable;
}
if (_modal != null)
{
return _frameAvailable;
}
return false;
}
public override void CreateWorld(RhinoDoc doc, ViewInfo viewInfo, DisplayPipelineAttributes displayPipelineAttributes)
{
}
public RenderEngine(Guid pluginId, uint docRuntimeSerialnumber, ViewInfo view, ViewportInfo vp, bool interactive)
{
PluginId = pluginId;
m_doc_serialnumber = docRuntimeSerialnumber;
m_view = view;
m_vp = vp;
m_interactive = interactive;
Database = new ChangeDatabase(PluginId, this, m_doc_serialnumber, m_view, !m_interactive);
RegisterEventHandler();
}
public PassRenderedEventArgs(int sample, ViewInfo view)
{
Sample = sample;
View = view;
}
public ModalRenderEngine(RhinoDoc doc, Guid pluginId, ViewInfo view, ViewportInfo viewport)
: base(pluginId, doc.RuntimeSerialNumber, view, viewport, false)
{
ModalRenderEngineCommonConstruct();
}
public void BackgroundWallpaper(ViewInfo view, bool scaleToFit)
{
_cqBackground.HandleWallpaper(view, scaleToFit);
}
internal ViewportInfo(ViewInfo parent)
{
m_parent = parent;
}
/// <summary>
/// Constructor for our changequeue implementation
/// </summary>
/// <param name="pluginId">Id of the plugin instantiating the render change queue</param>
/// <param name="engine">Reference to our render engine</param>
/// <param name="doc">Document runtime serial number</param>
/// <param name="view">Reference to the RhinoView for which this queue is created.</param>
/// <param name="modal">Set to true if rendering modal</param>
internal ChangeDatabase(Guid pluginId, RenderEngine engine, uint doc, ViewInfo view, bool modal)
: base(pluginId, doc, view, !modal)
{
_renderEngine = engine;
_objectShaderDatabase = new ObjectShaderDatabase(_objectDatabase);
_shaderConverter = new ShaderConverter(engine.Settings);
_modalRenderer = modal;
}
