/// <summary>
/// Finds the bounding box for the specified visual.
/// </summary>
/// <param name="visual">
/// The visual.
/// </param>
/// <param name="transform">
/// The transform of the visual.
/// </param>
/// <returns>
/// A <see cref="Rect3D"/>.
/// </returns>
public static Rect3D FindBounds(this Visual3D visual, Transform3D transform)
{
var bounds = Rect3D.Empty;
var childTransform = Transform3DHelper.CombineTransform(visual.Transform, transform);
var model = GetModel(visual);
if (model != null)
{
// apply transform
var transformedBounds = childTransform.TransformBounds(model.Bounds);
if (!double.IsNaN(transformedBounds.X))
{
bounds.Union(transformedBounds);
}
}
foreach (var child in GetChildren(visual))
{
var b = FindBounds(child, childTransform);
bounds.Union(b);
}
return(bounds);
}
/// <summary>
/// Gets the object space to world space transformation for the given Visual3D
/// </summary>
/// <param name="visual3DStart">The visual whose world space transform should be found</param>
/// <param name="viewport">The containing Viewport3D for the Visual3D</param>
/// <returns>The world space transformation</returns>
internal static Matrix3D GetWorldTransformationMatrix(Visual3D visual3DStart, out Viewport3DVisual viewport)
{
DependencyObject dependencyObject = visual3DStart;
Matrix3D worldTransform = Matrix3D.Identity;
while (dependencyObject != null)
{
Visual3D visual3D = dependencyObject as Visual3D;
// we reached the top
if (visual3D == null)
{
break;
}
Transform3D transform = (Transform3D)visual3D.GetValue(Visual3D.TransformProperty);
if (transform != null)
{
transform.Append(ref worldTransform);
}
dependencyObject = VisualTreeHelper.GetParent(dependencyObject);
}
if (dependencyObject != null)
{
viewport = (Viewport3DVisual)dependencyObject;
}
else
{
viewport = null;
}
return(worldTransform);
}
private void AddVisualForVisualizationObject(IRemoteVisualizationObject visualizationObject)
{
Visual3D visual = ((I3DVisualizationObject)visualizationObject).Visual3D;
this.SortingVisualRoot.Children.Add(visual);
}
public void Traverse <T>(Visual3D visual, Action <T, Transform3D> action) where T : Model3D
{
Traverse(visual, Transform3D.Identity, action);
}
private void Create()
{
if (source == null)
{
return;
}
IDataConsumer cons = this;
string x = source.Xaml;
string s = ProcessXaml(x);
Visual3D v3d = null;
object ob = System.Windows.Markup.XamlReader.Parse(s);
MeshGeometry3D mg = null;
if (ob is Visual3D)
{
v3d = ob as Visual3D;
List <MeshGeometry3D> lm = new List <MeshGeometry3D>();
Detect(v3d, lm);
xaml = x;
if (source == null)
{
return;
}
// MeshGeometry3D pattern = Mesh;
foreach (AlName an in al)
{
if (an.alias == null)
{
return;
}
if (an.name == null)
{
return;
}
}
foreach (IMeasurement mea in m)
{
if (mea == null)
{
return;
}
}
/* mg.Positions.Clear();
* for (int i = 0; i < pattern.Positions.Count; i++)
* {
* Point3D pat = pattern.Positions[i];
* //Point3D p = mg.Positions[i];
* for (int l = 0; l < 3; l++)
* {
* al[l].alias[al[l].name] = pat.GetCoordinate(l);
* }
* cons.UpdateChildrenData();
* Point3D p = new Point3D((double)m[0].Parameter(), (double)m[1].Parameter(), (double)m[2].Parameter());
* mg.Positions.Add(p);
* this.FullReset();
* }*/
lmesh.Clear();
foreach (MeshGeometry3D mh in lm)
{
Point3DCollection pp = mh.Positions;
Point3DCollection p = new Point3DCollection();
foreach (Point3D pat in pp)
{
for (int l = 0; l < 3; l++)
{
al[l].alias[al[l].name] = pat.GetCoordinate(l);
}
cons.UpdateChildrenData();
Point3D pr = new Point3D((double)m[0].Parameter(), (double)m[1].Parameter(), (double)m[2].Parameter());
p.Add(pr);
this.FullReset();
}
mh.Positions = p;
lmesh.Add(p);
}
//xaml = System.Windows.Markup.XamlWriter.Save(v3d);
}
}
public RenderItemListener(Visual3D visual, AegirLib.Behaviour.World.Transform item)
{
this.Visual = visual;
this.Item = item;
}
public NodeItem(Visual3D visual, ulong nodeId, MatrixTransform3D transform)
{
NodeId = nodeId;
Visual = visual;
Transform = transform;
}
public void Export(Visual3D visual, Patient p)
{
this.patient = p;
Traverse <GeometryModel3D>(visual, this.ExportModel);
finished = true;
}
public static void SetPrimitiveData(Visual3D target, SelectablePrimitive value)
{
target.SetValue(PrimitiveDataProperty, value);
}
public static SelectablePrimitive GetPrimitiveData(Visual3D target)
{
return((SelectablePrimitive)target.GetValue(PrimitiveDataProperty));
}
/// <summary>
/// Exports the specified visual.
/// </summary>
/// <param name="visual">
/// The visual.
/// </param>
public void Export(Visual3D visual)
{
this.ExportHeader();
Visual3DHelper.Traverse <GeometryModel3D>(visual, this.ExportModel);
}
public void AddDummy(AegirLib.Behaviour.World.Transform transformBehaviour)
{
Visual3D dummyVisual = VisualFactory.GetDummyVisual();
AddVisual(dummyVisual, transformBehaviour);
}
public SceneActor ResolveRenderItem(Visual3D visual)
{
return(VisualFactory?.GetRenderItem(RenderMode, visual));
}
public void Select(Visual3D visual)
{
this.SelectedObject = visual;
}
/// <summary>
/// Creates facets
/// </summary>
protected void CreateFacets()
{
if (facetCount > 0)
{
return;
}
Visual3D v3d = Visual;
if (mesh == null)
{
return;
}
mesh.Create(out areas, out centers);
Vector3DCollection coll = mesh.Normals;
facetCount = coll.Count;
colors = new Color[facetCount];
int n = coll.Count;
normals = new double[n][];
for (int i = 0; i < n; i++)
{
System.Windows.Media.Media3D.Vector3D v = coll[i];
double[] x = new double[] { v.X, v.Y, v.Z };
normals[i] = x;
}
if (bp == null)
{
return;
}
List <object> tt = new List <object>();
List <List <object> > par = new List <List <object> >();
System.Windows.Media.Int32Collection ic = bp.DoubleIndex;
System.Windows.Media.DoubleCollection dc = bp.DoubleParameters;
Double a = 0;
int kk = 0;
foreach (int i in ic)
{
tt.Add(new ArrayReturnType(a, new int[] { i }, false));
List <object> pp = new List <object>();
par.Add(pp);
for (int j = 0; j < facetCount; j++)
{
double[] x = new double[i];
pp.Add(x);
for (int k = 0; k < i; k++)
{
x[k] = dc[kk];
++kk;
}
}
}
types = tt.ToArray();
parameters = new object[par.Count][];
for (int i = 0; i < par.Count; i++)
{
parameters[i] = par[i].ToArray();
}
}
private void HitTest(Point mousePosition, out GeometryModel3D hitGeometryModel3D, out Visual3D hitVisual3D)
{
if (SimpleHitTestRadioButton.IsChecked ?? false)
{
// The most simple hit testing is done with calling HitTest method.
// This is the easiest option and can be used when we want to get the first hit object and do not need to filter hit objects.
_lastHitResult = VisualTreeHelper.HitTest(MainViewport, mousePosition) as RayMeshGeometry3DHitTestResult;
}
else if (CallbackRadioButton.IsChecked ?? false)
{
// A more advanced hit testing is done with using hit result callback.
// There we decide if we want to continue hit testing or stop the hit testing.
// This way it is possible to get all 3D objects under the mouse or do hit test filtering.
PointHitTestParameters pointParams = new PointHitTestParameters(mousePosition);
VisualTreeHelper.HitTest(MainViewport, null, HitTestResultHandler, pointParams);
}
else if (FilterAndCallbackRadioButton.IsChecked ?? false)
{
// When using hit result callback we can filter the hit objects in the HitTestResultHandler.
// But a better way to filer hit objects is to filter with using HitTestFilterCallback.
// This way we can skip hit testing on entire parts of the 3D hierarchy.
PointHitTestParameters pointParams = new PointHitTestParameters(mousePosition);
VisualTreeHelper.HitTest(MainViewport, HitTestFilterCallback, HitTestResultHandler, pointParams);
}
if (_lastHitResult != null)
{
hitGeometryModel3D = _lastHitResult.ModelHit as GeometryModel3D;
hitVisual3D = _lastHitResult.VisualHit;
}
else
{
hitGeometryModel3D = null;
hitVisual3D = null;
}
}
private Visual3D EnsureChild(Visual3D currentChild, Shape3DMaterial material)
{
Visual3D newChild = null;
if (material != null)
{
if (material.HasElement)
{
// We need a Viewport2DVisual3D to display an element.
if (currentChild is Viewport2DVisual3D)
{
newChild = currentChild;
}
else
{
//Viewbox viewbox = new Viewbox();
//viewbox.StretchDirection = StretchDirection.Both;
//viewbox.Stretch = Stretch.Fill;
Border border = new Border();
border.UseLayoutRounding = true;
border.Background = Brushes.Green;
//border.Child = viewbox;
Viewport2DVisual3D viewport = new Viewport2DVisual3D();
viewport.Visual = border;
newChild = viewport;
}
// Set the appropriate caching strategy.
CacheScale cacheScale = CacheScale;
if (cacheScale == null)
{
// Remove any VisualBrush caching.
RenderOptions.SetCachingHint(newChild, CachingHint.Unspecified);
// Remove any BitmapCache.
((Viewport2DVisual3D)newChild).CacheMode = null;
}
else if (cacheScale.IsAuto)
{
// Remove any BitmapCache.
((Viewport2DVisual3D)newChild).CacheMode = null;
// Specify VisualBrush caching with 2x min and max
// thresholds.
RenderOptions.SetCachingHint(newChild, CachingHint.Cache);
RenderOptions.SetCacheInvalidationThresholdMinimum(newChild, 0.5);
RenderOptions.SetCacheInvalidationThresholdMaximum(newChild, 2.0);
}
else
{
// Remove any VisualBrush caching.
RenderOptions.SetCachingHint(newChild, CachingHint.Unspecified);
// Set a BitmapCache with the appropriate scale.
BitmapCache bitmapCache = ((Viewport2DVisual3D)newChild).CacheMode as BitmapCache;
if (bitmapCache == null)
{
((Viewport2DVisual3D)newChild).CacheMode = new BitmapCache(cacheScale.Scale);
}
else
{
bitmapCache.RenderAtScale = cacheScale.Scale;
}
}
}
else
{
Debug.Assert(material.HasMaterial);
// We need a ModelVisual3D to display the material.
if (currentChild is ModelVisual3D)
{
Debug.Assert(((ModelVisual3D)currentChild).Content is GeometryModel3D);
newChild = currentChild;
}
else
{
newChild = new ModelVisual3D();
((ModelVisual3D)newChild).Content = new GeometryModel3D();
}
}
}
return(newChild);
}
/// <summary>
/// Determines if the specified visual is transparent.
/// </summary>
/// <param name="visual">
/// The visual.
/// </param>
/// <returns>
/// True if the visual is transparent.
/// </returns>
private bool IsVisualTransparent(Visual3D visual)
{
return(ElementSortingHelper.IsTransparent(visual));
}
/// <summary>
/// Initializes a new instance of the <see cref="ScreenGeometryBuilder"/> class.
/// </summary>
/// <param name="visual">
/// The visual.
/// </param>
protected ScreenGeometryBuilder(Visual3D visual)
{
this.visual = visual;
}
public void Start(Visual3D snappedPrimitive)
{
currentDragVector = new Vector3D(0, 0, 0);
currentSnappedPrimitive = snappedPrimitive;
originalDuplicate = null;
}
/// <summary>
/// Gets the distance squared.
/// </summary>
/// <param name="position">
/// The position.
/// </param>
/// <param name="visual">
/// The visual.
/// </param>
/// <returns>
/// The get distance squared.
/// </returns>
public static double GetDistanceSquared(Point3D position, Visual3D visual)
{
var bounds = Visual3DHelper.FindBounds(visual, Transform3D.Identity);
return(Point3D.Subtract(bounds.Location, position).LengthSquared);
}
public void Reset()
{
currentSnappedPrimitive = null;
currentDuplicate = null;
originalDuplicate = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="BillboardGeometryBuilder"/> class.
/// </summary>
/// <param name="visual">
/// The visual.
/// </param>
public BillboardGeometryBuilder(Visual3D visual)
: base(visual)
{
}
void eventSource3D_MouseEnter(object sender, Ab3d.DirectX.Common.EventManager3D.Mouse3DEventArgs e)
{
if (e.RayHitResult != null)
{
Log("MouseEnter: " + e.RayHitResult.HitSceneNode);
// We need to save the hit SceneNode.
// This way we will be able to change the material back in the eventSource3D_MouseLeave event handler.
_selectedVisual3D = e.RayHitResult.HitSceneNode.GetVisual3D();
var wpfGeometryModel3DNode = e.RayHitResult.HitSceneNode as WpfGeometryModel3DNode;
if (wpfGeometryModel3DNode != null)
{
_selectedGeometryModel3D = wpfGeometryModel3DNode.GeometryModel3D;
}
else
{
_selectedGeometryModel3D = null;
}
var dxRayInstancedHitTestResult = e.RayHitResult as DXRayInstancedHitTestResult;
if (dxRayInstancedHitTestResult != null)
{
_selectedInstanceIndex = dxRayInstancedHitTestResult.HitInstanceIndex;
}
if (_wireCrossVisual3D == null)
{
_wireCrossVisual3D = new WireCrossVisual3D()
{
LineColor = Colors.DeepPink,
LineThickness = 2,
LinesLength = 10
};
}
_wireCrossVisual3D.Position = e.RayHitResult.HitPosition.ToWpfPoint3D();
if (!MainViewport3D.Children.Contains(_wireCrossVisual3D))
{
MainViewport3D.Children.Add(_wireCrossVisual3D);
}
}
else
{
_selectedVisual3D = null;
_selectedGeometryModel3D = null;
_selectedInstanceIndex = -1;
Log("MouseEnter: <null>");
return;
}
if (_selectedInstanceIndex != -1)
{
ChangeInstanceColor(_selectedInstanceIndex, Colors.Red);
}
else
{
ChangeColor(e, Colors.Red);
}
}
/// <summary>
/// GetDescendantBounds returns the union of all of the content bounding
/// boxes of the specified Visual3D's sub-graph.
/// </summary>
public static Rect3D GetDescendantBounds(Visual3D reference)
{
CheckVisualReferenceArgument(reference);
return(reference.VisualDescendantBounds);
}
/// <summary>
/// Initializes a new instance of the <see cref="LineGeometryBuilder"/> class.
/// </summary>
/// <param name="visual">
/// The visual parent of the geometry (the transform is calculated from this object).
/// </param>
public LineGeometryBuilder(Visual3D visual)
: base(visual)
{
}
public void Export(Visual3D visual, Patient p)
{
//this.ExportHeader();
this.patient = p;
Traverse <GeometryModel3D>(visual, this.ExportModel);
}
private void UpdateDisplay()
{
if (current_game != Setting.param.Kind ||
current_quality != Setting.param.Quality ||
current_resolution != Setting.param.Resolution)
{
// ------------------------------
// Change mesh resolution
// ------------------------------
int div;
switch (Setting.param.Quality)
{
case 1:
div = 30;
break;
case 2:
div = 60;
break;
case 3:
default:
div = 90;
break;
}
double SamplingInterval = Math.PI / div;
UpdateMeshResolution((short)(1 << Setting.param.Resolution), SamplingInterval);
// ------------------------------
// Create game rule
// ------------------------------
if (Setting.param.Kind == GameKind.GAMEKIND_OTHELLO)
{
rule = new RuleOthello(pixelization);
}
else
{
rule = new RuleIgo(pixelization);
}
Title = rule.GetName();
// ------------------------------
// Remove all pieces
// ------------------------------
PieceArray2D = new UIElement[rule.GetMaxIndex()];
PieceArray3D = new Visual3D[rule.GetMaxIndex()];
canvas_projection_piece.Children.Clear();
PieceContainer.Children.Clear();
TerritoryArray2D = new UIElement[rule.GetMaxIndex()];
TerritoryArray3D = new Visual3D[rule.GetMaxIndex()];
canvas_projection_territory.Children.Clear();
TerritoryContainer.Children.Clear();
// ------------------------------
// Select UI panel
// ------------------------------
#if false
UserInterfaceArea.Children.Clear();
if (Setting.param.Kind == GameKind.GAMEKIND_IGO)
{
ConsoleIgo control = new ConsoleIgo();
UserInterfaceArea.Children.Add(control);
UserInterface = control;
}
else
{
ConsoleOthello control = new ConsoleOthello();
UserInterfaceArea.Children.Add(control);
UserInterface = control;
}
#else
if (Setting.param.Kind == GameKind.GAMEKIND_IGO)
{
UserInterface = PanelIgo;
TabItemIgo.IsSelected = true;
}
else
{
UserInterface = PanelOthello;
TabItemOthello.IsSelected = true;
}
#endif
UserInterface.SetOnConfigurationsChanged(delegate(object sender, System.EventArgs e) { UpdateDisplay(); });
UserInterface.SetGameRule(rule);
// ------------------------------
// Prepare initial piece arrangements
// ------------------------------
rule.SetPieceManipulator(ManipulatePiece);
rule.SetInitialPieces();
// ------------------------------
// Remember current settings
// ------------------------------
current_resolution = Setting.param.Resolution;
current_quality = Setting.param.Quality;
current_game = Setting.param.Kind;
}
SphereMaterial.Brush = new SolidColorBrush(Setting.param.ForeColor);
MapBase.Fill = SphereMaterial.Brush;
}
private void RemoveVisualForVisualizationObject(VisualizationObject visualizationObject)
{
Visual3D visual = ((I3DVisualizationObject)visualizationObject).Visual3D;
this.SortingVisualRoot.Children.Remove(visual);
}
/// <summary>
/// Gets the object space to world space transformation for the given Visual3D
/// </summary>
/// <param name="visual">The visual whose world space transform should be found</param>
/// <returns>The world space transformation</returns>
internal static Matrix3D GetWorldTransformationMatrix(Visual3D visual)
{
Viewport3DVisual ignored;
return(GetWorldTransformationMatrix(visual, out ignored));
}
