public RenderPackageFactoryViewModel(IPreferences preferenceSettings)
{
this.factory = new HelixRenderPackageFactory()
{
TessellationParameters = { ShowEdges = preferenceSettings.ShowEdges }
};
}
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);
}
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();
}
/// <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;
}
public void HighlightGizmo(IWatch3DViewModel backgroundPreviewViewModel,
IRenderPackageFactory factory)
{
var drawables = GetDrawablesForTransientGeometry(factory);
backgroundPreviewViewModel.AddGeometryForRenderPackages(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);
}
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();
}
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);
}
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);
}
/// <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 RenderPackageFactoryViewModel(IRenderPackageFactory factory)
{
this.factory = factory;
}
