/// <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; }