public RenderPackageFactoryViewModel(IPreferences preferenceSettings) { this.factory = new HelixRenderPackageFactory() { TessellationParameters = { ShowEdges = preferenceSettings.ShowEdges } }; }
private void RequestNodeVisualUpdateAsync(NodeModel nodeModel, IRenderPackageFactory factory) { if (nodeModel != null) { // Visualization update for a given node is desired. nodeModel.RequestVisualUpdateAsync( dynamoModel.Scheduler, dynamoModel.EngineController, factory); } else { // Get each node in workspace to update their visuals. foreach (var node in dynamoModel.CurrentWorkspace.Nodes) { node.RequestVisualUpdateAsync( dynamoModel.Scheduler, dynamoModel.EngineController, factory); } } // Schedule a NotifyRenderPackagesReadyAsyncTask here so that when // render packages of all the NodeModel objects are generated, the // VisualizationManager gets notified. // var scheduler = dynamoModel.Scheduler; var notifyTask = new NotifyRenderPackagesReadyAsyncTask(scheduler); notifyTask.Completed += OnNodeModelRenderPackagesReady; scheduler.ScheduleForExecution(notifyTask); }
public void HighlightGizmo(IWatch3DViewModel backgroundPreviewViewModel, IRenderPackageFactory factory) { var drawables = GetDrawablesForTransientGeometry(factory); backgroundPreviewViewModel.AddGeometryForRenderPackages(drawables); }
public VisualizationManager(DynamoModel model) { dynamoModel = model; dynamoModel.WorkspaceCleared += ClearVisualizations; dynamoModel.WorkspaceAdded += WorkspaceAdded; dynamoModel.WorkspaceRemoved += WorkspaceRemoved; dynamoModel.DeletionComplete += dynamoModel_DeletionComplete; dynamoModel.CleaningUp += Clear; dynamoModel.EvaluationCompleted += RequestAllNodesVisualsUpdate; dynamoModel.RequestsRedraw += RequestAllNodesVisualsUpdate; DynamoSelection.Instance.Selection.CollectionChanged += SelectionChanged; // The initial workspace will have been created before the viz manager // is created. So we have to hook to that workspace's events during // construction of the viz manager to make sure we don't miss handling // events from the pre-existing workspace. WorkspaceAdded(dynamoModel.CurrentWorkspace); renderPackageFactory = new HelixRenderPackageFactory(); RenderPackageFactory.TessellationParameters.ShowEdges = model.PreferenceSettings.ShowEdges; }
internal bool Initialize(UpdateRenderPackageParams initParams) { if (initParams == null) { throw new ArgumentNullException("initParams"); } if (initParams.Node == null) { throw new ArgumentNullException("initParams.Node"); } if (initParams.EngineController == null) { throw new ArgumentNullException("initParams.EngineController"); } if (initParams.DrawableIds == null) { throw new ArgumentNullException("initParams.DrawableIds"); } var nodeModel = initParams.Node; if (nodeModel.WasRenderPackageUpdatedAfterExecution && !initParams.ForceUpdate) { return(false); // Not has not been updated at all. } // If a node is in either of the following states, then it will not // produce any geometric output. Bail after clearing the render packages. if (nodeModel.IsInErrorState || !nodeModel.IsVisible) { return(false); } // Without AstIdentifierForPreview, a node cannot have MirrorData. if (string.IsNullOrEmpty(nodeModel.AstIdentifierForPreview.Value)) { return(false); } drawableIds = initParams.DrawableIds; if (!drawableIds.Any()) { return(false); // Nothing to be drawn. } displayLabels = nodeModel.DisplayLabels; isNodeSelected = nodeModel.IsSelected; factory = initParams.RenderPackageFactory; engineController = initParams.EngineController; previewIdentifierName = initParams.PreviewIdentifierName; nodeGuid = nodeModel.GUID; nodeModel.WasRenderPackageUpdatedAfterExecution = true; return(true); }
public GeometryHolder(DynamoModel model, IRenderPackageFactory factory, NodeModel nodeModel) { // Schedule the generation of render packages for this node. NodeRenderPackagesUpdated will be // called with the render packages when they are ready. The node will be set do 'Done' if the // sheduling for some reason is not successful (usually becuase the node have no geometry or is inivisible) node = nodeModel; nodeModel.RenderPackagesUpdated += NodeRenderPackagesUpdated; if (!nodeModel.RequestVisualUpdateAsync(model.Scheduler, model.EngineController, factory, true)) { // The node has no geometry so we are 'Done' Done.Set(); } }
protected Watch3DViewModelBase(Watch3DViewModelStartupParams parameters) { model = parameters.Model; scheduler = parameters.Scheduler; preferences = parameters.Preferences; logger = parameters.Logger; engineManager = parameters.EngineControllerManager; renderPackageFactory = parameters.RenderPackageFactory; viewModel = parameters.ViewModel; renderPackageFactoryViewModel = parameters.RenderPackageFactoryViewModel; Active = parameters.IsActiveAtStart; Name = parameters.Name; logger = parameters.Logger; RegisterEventHandlers(); }
// TODO: Simplify this constructor once IPreferences and IRenderPrecisionPreference have been consolidated in 3.0 (DYN-1699) public RenderPackageFactoryViewModel(IPreferences preferenceSettings) { var ps = preferenceSettings as PreferenceSettings; if (ps != null) { this.factory = new HelixRenderPackageFactory() { TessellationParameters = { ShowEdges = ps.ShowEdges, MaxTessellationDivisions = ps.RenderPrecision } }; } else { this.factory = new HelixRenderPackageFactory() { TessellationParameters = { ShowEdges = preferenceSettings.ShowEdges } }; } }
public RevitVisualizationManager(DynamoModel dynamoModel) : base(dynamoModel) { if (dynamoModel.Context == Context.VASARI_2014 || dynamoModel.Context == Context.REVIT_2015) { AlternateDrawingContextAvailable = true; DrawToAlternateContext = false; AlternateContextName = dynamoModel.Context; RequestAlternateContextClear += CleanupVisualizations; dynamoModel.CleaningUp += CleanupVisualizations; factory = new DefaultRenderPackageFactory(); } else { AlternateDrawingContextAvailable = false; } }
protected Watch3DViewModelBase(Watch3DViewModelStartupParams parameters) { model = parameters.Model; scheduler = parameters.Scheduler; preferences = parameters.Preferences; logger = parameters.Logger; engineManager = parameters.EngineControllerManager; renderPackageFactory = parameters.RenderPackageFactory; viewModel = parameters.ViewModel; renderPackageFactoryViewModel = parameters.RenderPackageFactoryViewModel; Active = parameters.Preferences.IsBackgroundPreviewActive; Name = parameters.Name; logger = parameters.Logger; RegisterEventHandlers(); TogglePanCommand = new DelegateCommand(TogglePan, CanTogglePan); ToggleOrbitCommand = new DelegateCommand(ToggleOrbit, CanToggleOrbit); ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground); }
/// <summary> /// Returns drawables for transient geometry associated with Gizmo /// </summary> /// <param name="factory"></param> /// <returns></returns> private List <IRenderPackage> GetDrawablesForTransientGeometry(IRenderPackageFactory factory) { var drawables = new List <IRenderPackage>(); if (null != hitAxis) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitAxis, "xAxisLine"); drawables.Add(package); } if (null != hitPlane) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.XAxis, "xAxisLine"); drawables.Add(package); package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.YAxis, "yAxisLine"); drawables.Add(package); } return(drawables); }
/// <summary> /// Gets drawables to render this Gizmo /// </summary> /// <param name="factory">Render package factory</param> /// <returns>List of render package</returns> public IEnumerable <IRenderPackage> GetDrawables(IRenderPackageFactory factory) { List <IRenderPackage> drawables = new List <IRenderPackage>(); foreach (var axis in axes) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxis(ref package, axis); drawables.Add(package); } var p = Planes.xyPlane; foreach (var plane in planes) { IRenderPackage package = factory.CreateRenderPackage(); DrawPlane(ref package, plane, p++); drawables.Add(package); } drawables.AddRange(GetDrawablesForTransientGeometry(factory)); return(drawables); }
public override void RequestVisualUpdateAsync( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory, bool forceUpdate = false) { //Do nothing }
public override bool RequestVisualUpdateAsync( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory, bool forceUpdate = false) { //Do nothing return(false); }
protected override void RequestVisualUpdateAsyncCore( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory) { // No visualization update is required for this node type. }
RequestVisualUpdateAsyncCore(IScheduler scheduler, EngineController engine, IRenderPackageFactory factory) { var initParams = new UpdateRenderPackageParams() { Node = this, RenderPackageFactory = factory, EngineController = engine, DrawableIds = GetDrawableIds(), PreviewIdentifierName = AstIdentifierForPreview.Name }; var task = new UpdateRenderPackageAsyncTask(scheduler); if (task.Initialize(initParams)) { task.Completed += OnRenderPackageUpdateCompleted; scheduler.ScheduleForExecution(task); } }
/// <summary> /// Call this method to asynchronously regenerate render package for /// this node. This method accesses core properties of a NodeModel and /// therefore is typically called on the main/UI thread. /// </summary> /// <param name="engine"></param> /// <param name="scheduler"></param> /// <param name="maxTessellationDivisions">The maximum number of /// tessellation divisions to use for regenerating render packages.</param> public void RequestVisualUpdateAsync(IScheduler scheduler, EngineController engine, IRenderPackageFactory factory) { //if (Workspace.DynamoModel == null) // return; // Imagine a scenario where "NodeModel.RequestVisualUpdateAsync" is being // called in quick succession from the UI thread -- the first task may // be updating '_renderPackages' when the second call gets here. In // this case '_renderPackages' should be protected against concurrent // accesses. // lock (RenderPackagesMutex) { renderPackages.Clear(); HasRenderPackages = false; } RequestVisualUpdateAsyncCore(scheduler, engine, factory); }
/// <summary> /// Gets drawables to render this Gizmo /// </summary> /// <param name="factory">Render package factory</param> /// <returns>List of render package</returns> public IEnumerable<IRenderPackage> GetDrawables(IRenderPackageFactory factory) { List<IRenderPackage> drawables = new List<IRenderPackage>(); foreach (var axis in axes) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxis(ref package, axis); drawables.Add(package); } var p = Planes.xyPlane; foreach (var plane in planes) { IRenderPackage package = factory.CreateRenderPackage(); DrawPlane(ref package, plane, p++); drawables.Add(package); } drawables.AddRange(GetDrawablesForTransientGeometry(factory)); return drawables; }
public override bool RequestVisualUpdateAsync(IScheduler scheduler, EngineController engine, IRenderPackageFactory factory, bool forceUpdate = true) { try { int index = OutPorts[0].Index; string name = GetAstIdentifierForOutputIndex(index).Name; RuntimeMirror mirror = engine.GetMirror(name); MirrorData data = mirror.GetData(); List <Autodesk.DesignScript.Geometry.Mesh> meshes = GetMeshes(data); _meshes = meshes; IRenderPackage render = factory.CreateRenderPackage(); foreach (Autodesk.DesignScript.Geometry.Mesh m in meshes) { if (m != null) { m.Tessellate(render, factory.TessellationParameters); //var method = render.GetType().GetMethod("SetTransform", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance, null, new[] { typeof(double[]) }, null); //if (method != null) //{ // method.Invoke(render, new object[] { new double[] // { // transform.XAxis.X, transform.XAxis.Y, transform.XAxis.Z, 0, // transform.YAxis.X, transform.YAxis.Y, transform.YAxis.Z, 0, // transform.ZAxis.X, transform.ZAxis.Y, transform.ZAxis.Z, 0, // transform.Origin.X, transform.Origin.Y, transform.Origin.Z, 1 // } // }); //} } } // NOTE: I'm not sure calling the Tessellate method from IGraphicItem is necessary here // but I've tried calling and am leaving it in here just in case I do wind up needing it. //Tessellate(render, factory.TessellationParameters); return(true); } catch { } return(false); }
/// <summary> /// Sets up the provided <see cref="DefaultWatch3DViewModel"/> object and /// adds it to the Watch3DViewModels collection. /// </summary> /// <param name="watch3DViewModel"></param> /// <param name="factory"></param> protected void RegisterWatch3DViewModel(DefaultWatch3DViewModel watch3DViewModel, IRenderPackageFactory factory) { watch3DViewModel.Setup(this, factory); watch3DViewModels.Add(watch3DViewModel); watch3DViewModel.Active = PreferenceSettings .GetIsBackgroundPreviewActive(watch3DViewModel.PreferenceWatchName); RaisePropertyChanged("Watch3DViewModels"); }
protected override void RequestVisualUpdateAsyncCore( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory) { // Do nothing }
public override void RequestVisualUpdateAsync( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory, bool forceUpdate = false) { // No visualization update is required for this node type. }
/// <summary> /// Call setup to establish the visualization context for the /// Watch3DViewModel. Because the Watch3DViewModel is passed into the DynamoViewModel, /// Setup is required to fully establish the rendering context. /// </summary> /// <param name="viewModel">An IDynamoViewModel object.</param> /// <param name="renderPackageFactory">An IRenderPackageFactory object.</param> public void Setup(IDynamoViewModel viewModel, IRenderPackageFactory renderPackageFactory) { this.viewModel = viewModel; this.renderPackageFactory = renderPackageFactory; }
public override bool RequestVisualUpdateAsync( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory, bool forceUpdate = false) { // No visualization update is required for this node type. return false; }
public RenderPackageFactoryViewModel(IRenderPackageFactory factory) { this.factory = factory; }
protected override void RequestVisualUpdateAsyncCore( IScheduler scheduler, EngineController engine, IRenderPackageFactory factory) { //Do nothing }
internal bool Initialize(UpdateRenderPackageParams initParams) { if (initParams == null) throw new ArgumentNullException("initParams"); if (initParams.Node == null) throw new ArgumentNullException("initParams.Node"); if (initParams.EngineController == null) throw new ArgumentNullException("initParams.EngineController"); if (initParams.DrawableIds == null) throw new ArgumentNullException("initParams.DrawableIds"); var nodeModel = initParams.Node; if (!nodeModel.WasInvolvedInExecution && !initParams.ForceUpdate) return false; // Not has not been updated at all. // If a node is in either of the following states, then it will not // produce any geometric output. Bail after clearing the render packages. if (nodeModel.IsInErrorState || !nodeModel.IsVisible) return false; // Without AstIdentifierForPreview, a node cannot have MirrorData. if (string.IsNullOrEmpty(nodeModel.AstIdentifierForPreview.Value)) return false; drawableIds = initParams.DrawableIds; if (!drawableIds.Any()) return false; // Nothing to be drawn. displayLabels = nodeModel.DisplayLabels; isNodeSelected = nodeModel.IsSelected; factory = initParams.RenderPackageFactory; engineController = initParams.EngineController; previewIdentifierName = initParams.PreviewIdentifierName; nodeGuid = nodeModel.GUID; return true; }
/// <summary> /// Gets drawables to render this Gizmo /// </summary> /// <param name="factory">Render package factory</param> /// <returns>List of render package</returns> public IEnumerable<IRenderPackage> GetDrawables(IRenderPackageFactory factory) { List<IRenderPackage> drawables = new List<IRenderPackage>(); foreach (var axis in axes) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxis(ref package, axis); drawables.Add(package); } var p = Planes.xyPlane; foreach (var plane in planes) { IRenderPackage package = factory.CreateRenderPackage(); DrawPlane(ref package, plane, p++); drawables.Add(package); } if(null != hitAxis) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitAxis, "xAxisLine"); drawables.Add(package); } if(null != hitPlane) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.XAxis, "xAxisLine"); drawables.Add(package); package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.YAxis, "yAxisLine"); drawables.Add(package); } return drawables; }
/// <summary> /// Returns drawables for transient geometry associated with Gizmo /// </summary> /// <param name="factory"></param> /// <returns></returns> private List<IRenderPackage> GetDrawablesForTransientGeometry(IRenderPackageFactory factory) { var drawables = new List<IRenderPackage>(); if (null != hitAxis) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitAxis, "xAxisLine"); drawables.Add(package); } if (null != hitPlane) { IRenderPackage package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.XAxis, "xAxisLine"); drawables.Add(package); package = factory.CreateRenderPackage(); DrawAxisLine(ref package, hitPlane.YAxis, "yAxisLine"); drawables.Add(package); } return drawables; }
/// <summary> /// Sets up the provided <see cref="DefaultWatch3DViewModel"/> object and /// adds it to the Watch3DViewModels collection. /// </summary> /// <param name="watch3DViewModel"></param> /// <param name="factory"></param> protected void RegisterWatch3DViewModel(DefaultWatch3DViewModel watch3DViewModel, IRenderPackageFactory factory) { watch3DViewModel.Setup(this, factory); watch3DViewModels.Add(watch3DViewModel); RaisePropertyChanged("Watch3DViewModels"); }
public VisualizationManager(DynamoModel model) { dynamoModel = model; dynamoModel.WorkspaceClearing += Stop; dynamoModel.WorkspaceCleared += ClearVisualizationsAndRestart; dynamoModel.WorkspaceAdded += WorkspaceAdded; dynamoModel.WorkspaceRemoved += WorkspaceRemoved; dynamoModel.DeletionStarted += Stop; dynamoModel.DeletionComplete += dynamoModel_DeletionComplete; dynamoModel.CleaningUp += Clear; dynamoModel.EvaluationCompleted += RequestAllNodesVisualsUpdate; dynamoModel.RequestsRedraw += RequestAllNodesVisualsUpdate; DynamoSelection.Instance.Selection.CollectionChanged += SelectionChanged; // The initial workspace will have been created before the viz manager // is created. So we have to hook to that workspace's events during // construction of the viz manager to make sure we don't miss handling // events from the pre-existing workspace. WorkspaceAdded(dynamoModel.CurrentWorkspace); renderPackageFactory = new HelixRenderPackageFactory(); RenderPackageFactory.TessellationParameters.ShowEdges = model.PreferenceSettings.ShowEdges; Start(); }