private void SetButtonIcon()
{
_withIcon = !string.IsNullOrEmpty(_materialButton.Image);
if (_withIcon)
{
var fileName = _materialButton.Image.File.Split('.').First();
var id = this.Resources.GetIdentifier(fileName, "drawable", Material.Context.PackageName);
var width = (int)MaterialHelper.ConvertToDp(18);
var height = (int)MaterialHelper.ConvertToDp(18);
var drawable = MaterialHelper.GetDrawableCopyFromResource <Drawable>(id);
drawable.SetBounds(0, 0, width, height);
drawable.SetTint(_materialButton.TextColor.ToAndroid());
this.Control.SetCompoundDrawables(drawable, null, null, null);
this.Control.CompoundDrawablePadding = 8;
}
}
public Model3DGroup GetModel()
{
Model3DGroup model3DGroup = new Model3DGroup();
meshs.ForEach(x =>
{
List <Point3D> list1 = new List <Point3D>();
List <Vector3D> list2 = new List <Vector3D>();
List <Point> list3 = new List <Point>();
for (int i = 0; i < x.vertices.Count; ++i)
{
list1.Add(x.vertices[i].position);
list2.Add(x.normals[i]);
list3.Add(x.vertices[i].uvcoord);
}
List <int> list4 = new List <int>();
x.faces.ForEach(y =>
{
list4.Add(y[0]);
list4.Add(y[1]);
list4.Add(y[2]);
});
MeshGeometry3D geometry = new MeshGeometry3D
{
Normals = new Vector3DCollection(list2),
Positions = new Point3DCollection(list1),
TextureCoordinates = new PointCollection(list3),
TriangleIndices = new Int32Collection(list4)
};
Material material = Materials.Gray;
byte[] buffer = MainWindow.Buildings.ReadFile(x.texture[0].ToLower());
if (buffer.Length > 0)
{
material = MaterialHelper.CreateImageMaterial(ToImage(buffer), 1.0);
}
model3DGroup.Children.Add(new GeometryModel3D
{
Geometry = geometry,
Material = material,
BackMaterial = material
});
});
return(model3DGroup);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
// Create a model group
var modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddBox(new Point3D(0, 5, 5), 2, 2, 5);
meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 1, 5, 0.4));
MeshGeometry3D g = new MeshGeometry3D();
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
// Create some materials
var greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
var redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
var blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
//The Importer to load .obj files
ModelImporter importer = new ModelImporter();
//The Material (Color) that is applyed to the importet objects
Material material = new DiffuseMaterial(new SolidColorBrush(Colors.White));
importer.DefaultMaterial = material;
Model3D block = importer.Load(@"D:\Program Files (x86)\Steam\SteamApps\workshop\content\387990\877698157\Objects\Mesh\Seat.obj");
//modelGroup.Children.Add(block);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh, Material = greenMaterial, BackMaterial = insideMaterial
});
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(-2, 0, 0), Material = redMaterial, BackMaterial = insideMaterial });
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(2, 0, 0), Material = blueMaterial, BackMaterial = insideMaterial });
// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
this.Model = modelGroup;
}
public VertexUI(Vertex vertex) : base(vertex)
{
Vertex = vertex;
var sphere = new SphereVisual3D();
sphere.Model.Material = MaterialHelper.CreateMaterial(Color.FromRgb(255, 0, 0));
sphere.Center = vertex.Point.Multiply(SCALE_FACTOR);
sphere.Radius = sphere.Radius * 0.5;
VisualElement = sphere;
Material colorMaterial;
switch (vertex.Type)
{
case 0:
colorMaterial = DefaultVertexMaterial;
break;
case 1:
colorMaterial = BindVertexMaterial;
break;
case 2:
colorMaterial = ControlVertexMaterial;
break;
case 3:
colorMaterial = MassVertexMaterial;
break;
default:
colorMaterial = UnknownVertexMaterial;
break;
}
var groupMaterial = new MaterialGroup();
groupMaterial.Children.Add(colorMaterial);
Material = groupMaterial;
Title = "Узел №" + vertex.Number;
}
private void AddEdge(ModelUIElement3D element, Point3D center, double x, double y, double z, Vector3D faceNormal)
{
var builder = new MeshBuilder(false, true);
builder.AddBox(center, x, y, z);
var geometry = builder.ToMesh();
geometry.Freeze();
var model = new GeometryModel3D {
Geometry = geometry, Material = MaterialHelper.CreateMaterial(EdgeBrush)
};
element.Model = model;
faceNormals.Add(element, faceNormal);
faceUpVectors.Add(element, ModelUpDirection);
}
//public event EventHandler ModelVisualizationRequested;
public MainWindow()
{
InitializeComponent();
m_replacementMaterial = MaterialHelper.CreateMaterial(Brushes.LightBlue, 0.0, 40);
m_backReplacementMaterial = MaterialHelper.CreateMaterial(Brushes.Green, 0.0, 40);
m_viewModel = new MainViewModel
{
ShownVisual3d = new ModelVisual3D()
};
this.DataContext = m_viewModel;
m_visualizerPreparationStage = ServicePreparationStage.NotOpened;
if (TryOpenVisualizerService())
{
TryReconnect();
}
OnResetCameraClick(this, null);
}
private void AddBases(ModelVisual3D model, int number, double turns, double length)
{
var b = turns * 2 * Math.PI;
var l = length;
var p1 = 0d;
var p2 = 3.14;
for (int i = 0; i < number; i++)
{
var u = (double)i / (number - 1);
var bu = b * u;
var x1 = Math.Cos(bu + p1) + Math.Cos(bu + p1);
var y1 = Math.Sin(bu + p1) + Math.Sin(bu + p1);
var z = u * l;
var x2 = Math.Cos(bu + p2) + Math.Cos(bu + p2);
var y2 = Math.Sin(bu + p2) + Math.Sin(bu + p2);
var pt1 = new Point3D(x1, y1, z);
var pt2 = new Point3D(x2, y2, z);
var pt3 = new Point3D(0, 0, z);
var j = r.Next(4);
var brush1 = BaseBrush1[j];
var brush2 = BaseBrush2[j];
var ts = new PipeVisual3D
{
Point1 = pt1,
Point2 = pt3,
Diameter = 0.4,
Material = MaterialHelper.CreateMaterial(brush1)
};
model.Children.Add(ts);
var ts2 = new PipeVisual3D
{
Point1 = pt3,
Point2 = pt2,
Diameter = 0.4,
Material = MaterialHelper.CreateMaterial(brush2)
};
model.Children.Add(ts2);
}
}
private GradientDrawable CreateShapeDrawable(float cornerRadius, int borderWidth, Color backgroundColor, Color borderColor)
{
GradientDrawable shapeDrawable = null;
if (_button.ButtonType != MaterialButtonType.Text)
{
shapeDrawable = _withIcon ? MaterialHelper.GetDrawableCopyFromResource <GradientDrawable>(Resource.Drawable.drawable_shape_with_icon) : MaterialHelper.GetDrawableCopyFromResource <GradientDrawable>(Resource.Drawable.drawable_shape);
}
else
{
shapeDrawable = MaterialHelper.GetDrawableCopyFromResource <GradientDrawable>(Resource.Drawable.drawable_shape_text);
}
shapeDrawable.SetCornerRadius(cornerRadius);
shapeDrawable.SetColor(backgroundColor);
shapeDrawable.SetStroke(borderWidth, borderColor);
return(shapeDrawable);
}
GeometryModel3D AddGeometry(IEnumerable <Point3D> centers, double l)
{
var builder = new MeshBuilder();
foreach (var center in centers)
{
builder.AddPyramid(center, l, l, true);
}
var mv = new GeometryModel3D
{
Geometry = builder.ToMesh(true),
Material = MaterialHelper.CreateMaterial(Brushes.Gold)
};
TriangleCount = builder.TriangleIndices.Count / 3;
return(mv);
}
public void runDemoModel()
{
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddBox(new Point3D(0, 0, 1), 1, 2, 0.5);
meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 0.5, 1, 0.4));
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
// Create some materials
var greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
//create a model
this.Model = new GeometryModel3D {
Geometry = mesh, Transform = new TranslateTransform3D(0, 0, 0), Material = greenMaterial, BackMaterial = greenMaterial
};
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
// Create a model group
var modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddBox(new Point3D(0, 0, 1), 1, 2, 0.5);
meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 0.5, 1, 0.4));
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
// Create some materials
var greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
var redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
var blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh, Material = greenMaterial, BackMaterial = insideMaterial
});
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh, Transform = new TranslateTransform3D(-2, 0, 0), Material = redMaterial, BackMaterial = insideMaterial
});
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh, Transform = new TranslateTransform3D(2, 0, 0), Material = blueMaterial, BackMaterial = insideMaterial
});
//// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
//AxisAngleRotation3D rotateAxis = new AxisAngleRotation3D(new Vector3D(0, 1, 0), 180/*or 360*/);
//Rotation3DAnimation rotateAnimation = new Rotation3DAnimation(rotateAxis, TimeSpan.FromSeconds(2));
//var rotateTransform = new RotateTransform3D();
//rotateTransform.BeginAnimation(RotateTransform3D.RotationProperty, rotateAnimation);
//modelGroup.Transform = rotateTransform;
this.Model = modelGroup;
}
private void CreateContainedButtonDrawable(bool elevated)
{
var normalStateDrawable = this.CreateShapeDrawable(_cornerRadius, _borderWidth, _normalColor, _borderColor);
var disabledStateDrawable = this.CreateShapeDrawable(_cornerRadius, _borderWidth, _disabledColor, _disabledBorderColor);
if (Material.IsLollipop)
{
var rippleColor = _normalColor.IsColorDark() ? Color.ParseColor("#52FFFFFF") : Color.ParseColor("#52000000");
var rippleDrawable = _withIcon ? MaterialHelper.GetDrawableCopyFromResource <RippleDrawable>(Resource.Drawable.drawable_ripple_with_icon) : MaterialHelper.GetDrawableCopyFromResource <RippleDrawable>(Resource.Drawable.drawable_ripple);
var insetDrawable = rippleDrawable.FindDrawableByLayerId(Resource.Id.inset_drawable) as InsetDrawable;
var statelistDrawable = insetDrawable.Drawable as StateListDrawable;
this.SetStates(statelistDrawable, normalStateDrawable, normalStateDrawable, disabledStateDrawable);
rippleDrawable.SetColor(new Android.Content.Res.ColorStateList(new int[][]
{
new int[] {}
},
new int[]
{
rippleColor
}));
this.Control.Background = rippleDrawable;
this.Control.StateListAnimator = elevated ? AnimatorInflater.LoadStateListAnimator(this.Context, Resource.Animator.material_button_state_list_anim) : null;
}
else if (Material.IsJellyBean)
{
var stateListDrawable = new StateListDrawable();
var pressedStateDrawable = this.CreateShapeDrawable(_cornerRadius, _borderWidth, _pressedColor, _borderColor);
this.SetStates(stateListDrawable, normalStateDrawable, pressedStateDrawable, disabledStateDrawable);
this.Control.Background = stateListDrawable;
}
else
{
var insetDrawable = MaterialHelper.GetDrawableCopyFromResource <InsetDrawable>(Resource.Drawable.drawable_selector);
var stateListDrawable = insetDrawable.Drawable as StateListDrawable;
var pressedStateDrawable = this.CreateShapeDrawable(_cornerRadius, _borderWidth, _pressedColor, _borderColor);
this.SetStates(stateListDrawable, normalStateDrawable, pressedStateDrawable, disabledStateDrawable);
this.Control.Background = insetDrawable;
}
}
/// <summary>
/// Make viewport geometry for triangles
/// </summary>
private static List <GeometryModel3D> _geometryFromTriangles(Point3DCollection vertices, Int32Collection triangles)
{
var material = MaterialHelper.CreateMaterial(Colors.LightGray); // Just in case, not to accidentally remain invisible (consequence of null)
var mesh = new MeshGeometry3D()
{
Positions = vertices,
TriangleIndices = triangles
};
var geom = new GeometryModel3D()
{
Geometry = mesh,
Material = material,
BackMaterial = null
};
var geomList = new List <GeometryModel3D>();
geomList.Add(geom);
return(geomList);
}
public static Model3D DrawLines(List <Line> lines, double diameter, int resolutiontube, System.Windows.Media.Media3D.Material mat)
{
var modelGroup = new Model3DGroup();
var meshBuilder = new MeshBuilder(false, false);
foreach (Line l in lines)
{
meshBuilder.AddCylinder(RhinoToHelixPoint(l.From), RhinoToHelixPoint(l.To), diameter, resolutiontube); // resolution hard-coded, section parameter = radius
}
var mesh = meshBuilder.ToMesh(true);
var CMaterial = MaterialHelper.CreateMaterial(Colors.Gray);
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh, Material = CMaterial, BackMaterial = CMaterial
});
// Assign modelGroup to model to draw
return(modelGroup);
}
/// <summary>
/// Calculates the texture of the specified model.
/// </summary>
/// <param name="model">
/// The model.
/// </param>
/// <param name="mesh">
/// The mesh.
/// </param>
public override void Calculate(TerrainModel model, MeshGeometry3D mesh)
{
var normals = MeshGeometryHelper.CalculateNormals(mesh);
var texcoords = new PointCollection();
for (int i = 0; i < normals.Count; i++)
{
double slopedir = Math.Atan2(normals[i].Y, normals[i].X) * 180 / Math.PI;
if (slopedir < 0)
{
slopedir += 360;
}
double u = slopedir / 360;
texcoords.Add(new Point(u, u));
}
this.TextureCoordinates = texcoords;
this.Material = MaterialHelper.CreateMaterial(this.Brush);
}
internal void sample(Color color)
{
///*
GeometryModel3D bigCubeModel = GeometryGenerator.CreateCubeModel();
bigCubeModel.Material = MaterialHelper.CreateMaterial(new SolidColorBrush(color));
this.Content = bigCubeModel;
Rect3D r = this.Parent.Content.Bounds;
double min = Math.Min(r.SizeX, Math.Min(r.SizeY, r.SizeZ));
Transform3DGroup transformGroup = new Transform3DGroup();
//transformGroup.Children.Add(new TranslateTransform3D(0.5 * parent.Children.Count, 0, 0));
//transformGroup.Children.Add(new TranslateTransform3D(new Point3D(r.X, r.Y, r.Z).ToVector3D()));
//transformGroup.Children.Add(new ScaleTransform3D(new Vector3D(r.SizeY, r.SizeY, r.SizeY), new Point3D(r.X,r.Y,r.Z)));
transformGroup.Children.Add(new TranslateTransform3D(parent.rootPoint().ToVector3D()));
transformGroup.Children.Add(new ScaleTransform3D(new Vector3D(min, min, min), parent.rootPoint()));
this.Transform = transformGroup;
//*/
}
/// <summary>
/// The load image.
/// </summary>
/// <param name="url">
/// The url.
/// </param>
/// <param name="setter">
/// The setter.
/// </param>
private void LoadImage(string url, Action <Material> setter)
{
var client = new WebClient();
client.DownloadDataCompleted += (sender, e) =>
{
if (e.Error != null)
{
return;
}
var image = new BitmapImage();
image.BeginInit();
image.StreamSource = new MemoryStream(e.Result);
image.EndInit();
setter(MaterialHelper.CreateImageMaterial(image, 0.5));
};
client.DownloadDataAsync(new Uri(url));
}
private static void CreatePolygon(VectorTileFeature feature, Pallete pallete, Model3DGroup model3DGroup, Vector2 <int> shiftCoords)
{
PointCollection points = new PointCollection();
List <List <Vector2 <int> > > list = feature.Geometry <int>();
foreach (List <Vector2 <int> > item in list)
{
points.Clear();
foreach (Vector2 <int> point in item)
{
points.Add(new Point(point.X + shiftCoords.X, point.Y + shiftCoords.Y));
}
points.RemoveAt(points.Count - 1);
var model = new GeometryModel3D();
var meshbuilder = new MeshBuilder(true, true);
var result = CuttingEarsTriangulator.Triangulate(points);
List <int> tri = new List <int>();
for (int i = 0; i < result.Count; i++)
{
tri.Add(result[i]);
if (tri.Count == 3)
{
//Console.WriteLine("Triangle " + (i / 3).ToString() + " : " + tri[0].ToString() + ", " + tri[1].ToString() + ", " + tri[2].ToString());
meshbuilder.AddTriangle(new Point3D(points[tri[0]].X, points[tri[0]].Y, 1),
new Point3D(points[tri[1]].X, points[tri[1]].Y, 1),
new Point3D(points[tri[2]].X, points[tri[2]].Y, 1));
tri.Clear();
}
}
model.Geometry = meshbuilder.ToMesh();
model.Material = MaterialHelper.CreateMaterial(pallete.MainFillColor.ToMediaColor());
model3DGroup.Children.Add(model);
}
}
private void StartBtnClick(object sender, RoutedEventArgs e)
{
this.viewPort3d.Children.Remove(device3D);
Point mousePos = PointToScreen(Mouse.GetPosition(sender as Button));
//var sphereSize = 5;
/* keep these values low, the higher the values the more detailed the sphere which may impact your rendering perfomance.*/
//var phi = 12;
//var theta = 12;
foreach (SensorsData sensor in sensorsDataList)
{
MeshBuilder meshBuilder = new MeshBuilder();
meshBuilder.AddBox(new Point3D(sensor.x, sensor.y, sensor.deltaZ), 20, 20, 0.005);
//meshBuilder.AddCylinder(new Point3D(sensor.x+100, sensor.y+100, sensor.deltaZ), new Point3D(sensor.x+100, sensor.y+100, sensor.deltaZ + 10), 10, 12);
//meshBuilder.AddSphere(new Point3D(sensor.x, sensor.y, sensor.z), sphereSize, theta, phi);
GeometryModel3D sphereModel;
if (sensor.deltaZ >= 2)
{
sphereModel = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(Brushes.Red, null, null, 1, 0));
}
else if (sensor.deltaZ < 2 && sensor.deltaZ > -2)
{
sphereModel = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(Brushes.Red));
}
else
{
sphereModel = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(Brushes.LawnGreen, null, null, 1, 0));
}
groupModel.Children.Add(sphereModel);
}
device3D.Content = groupModel;
this.viewPort3d.Children.Add(device3D);
}
public MainWindow()
{
InitializeComponent();
Loaded += MainWindow_Loaded;
Clouds = MaterialHelper.CreateMaterial(Brushes.Transparent);
// set this to true to download the latest cloud image (from the url specified above)
loadCurrent = false;
if (loadCurrent)
{
var client = new WebClient();
client.DownloadDataCompleted += client_DownloadDataCompleted;
client.DownloadDataAsync(new Uri(url));
}
else
{
SetDefaultClouds();
}
DataContext = this;
}
public override void CreatePreview()
{
if (Preview != null)
{
return;
}
Preview = DoCreatePreview();
Preview.GetComponent <Renderer>().material = MaterialHelper.GetNextMaterial(Id.GetHashCode());
foreach (var c in Preview.GetComponents <Collider>())
{
c.enabled = false;
Object.Destroy(c);
}
Preview.transform.SetParent(Collider.transform, false);
SyncPreview();
RefreshHighlighted();
}
public MandelbrotMountain()
{
solver = new MandelbrotSolver();
var brush = new LinearGradientBrush();
brush.StartPoint = new Point(0, 0);
brush.EndPoint = new Point(1, 0);
brush.GradientStops.Add(new GradientStop(Color.FromRgb(0, 7, 100), 0));
brush.GradientStops.Add(new GradientStop(Color.FromRgb(32, 107, 203), 0.15));
brush.GradientStops.Add(new GradientStop(Color.FromRgb(237, 255, 255), 0.42));
brush.GradientStops.Add(new GradientStop(Color.FromRgb(255, 170, 0), 0.64));
brush.GradientStops.Add(new GradientStop(Color.FromRgb(0, 0, 0), 0.854));
// brush.GradientStops.Add(new GradientStop(Color.FromRgb(0, 7, 100), 1.0));
gradientMaterial = MaterialHelper.CreateMaterial(brush, null, Brushes.Gray, 1.0, 200);
MaxIterations = 32;
HeightFactor = 0.3;
Generate();
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
// Create a model group
var modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddBox(new Point3D(0, 0, 1), 1, 2, 0.5);
meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 0.5, 1, 0.4));
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
var meshBuilder1 = new MeshBuilder(false, false);
meshBuilder1.AddCylinder(new Point3D(-10, 20, 0), new Point3D(10, 10, 0), 0.05);
var mesh1 = meshBuilder1.ToMesh(true);
// Create some materials
var greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
var redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
var blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Material = greenMaterial, BackMaterial = insideMaterial });
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(-2, 0, 0), Material = redMaterial, BackMaterial = insideMaterial });
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(2, 0, 0), Material = blueMaterial, BackMaterial = insideMaterial });
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh1, Material = redMaterial, BackMaterial = insideMaterial
});
// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
this.Model = modelGroup;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
// Create a model group
var modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddSphere(new Point3D(0, 0, 0), 0.5);
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
var blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
var greyMaterial = MaterialHelper.CreateMaterial(Colors.LightGray);
List <TranslateTransform3D> transformations = GetAllSheres();
transformations.ForEach(
f =>
modelGroup.Children.Add(new GeometryModel3D
{
Geometry = mesh,
Transform = f,
Material = blueMaterial,
BackMaterial = insideMaterial
}));
// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
this.Model = modelGroup;
Thread t = new Thread(Do);
t.Start();
//Do();
}
public Quad SetupSubQuad(QuadPosition quadPosition)
{
GameObject go = new GameObject(string.Format("Quad_{0}", quadPosition));
Mesh mesh = GetMesh(quadPosition);
mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2));
Material material = MaterialHelper.CreateTemp(ColorShader, "Quad");
Quad quadComponent = go.AddComponent <Quad>();
quadComponent.Planetoid = this;
quadComponent.QuadMesh = mesh;
quadComponent.QuadMaterial = material;
quadComponent.SetupCorners(quadPosition);
if (Atmosphere != null)
{
Atmosphere.InitUniforms(null, quadComponent.QuadMaterial, false);
}
QuadGenerationConstants gc = QuadGenerationConstants.Init(TerrainMaxHeight);
gc.planetRadius = PlanetRadius;
quadComponent.Position = quadPosition;
quadComponent.generationConstants = gc;
quadComponent.ShouldDraw = false;
if (qdtccc == null)
{
qdtccc = new QuadDistanceToClosestCornerComparer();
}
Quads.Add(quadComponent);
Quads.Sort(qdtccc);
return(quadComponent);
}
public void Init()
{
// Create a model group
modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
MeshBuilder meshBuilder = new MeshBuilder(false, false);
//meshBuilder.AddBox(new Point3D(0, 0, 1), 1, 2, 0.5);
//meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 0.5, 1, 0.4));
meshBuilder.AddEllipsoid(new Point3D(1, 1, 1), 2, 2, 2);
//meshBuilder.AddArrow(new Point3D(0,0,0),new Point3D(10,10,10),2 );
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
// Create some materials
greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
materialBuffer.Add(Colors.Green, greenMaterial);
materialBuffer.Add(Colors.Red, redMaterial);
materialBuffer.Add(Colors.Blue, blueMaterial);
materialBuffer.Add(Colors.Yellow, insideMaterial);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
modelGroup.Children.Add(new GeometryModel3D {
Geometry = mesh, Material = greenMaterial, Transform = new TranslateTransform3D(0, 0, 0), BackMaterial = insideMaterial
});
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(-2, 0, 0), Material = redMaterial, BackMaterial = insideMaterial });
//modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(2, 0, 0), Material = blueMaterial, BackMaterial = insideMaterial });
// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
this.Model = modelGroup;
defaultMaterial = blueMaterial;
}
protected override void InitNode()
{
InitOceanNode();
OceanMaterial = MaterialHelper.CreateTemp(OceanShader, "Ocean");
ParentBody.Atmosphere.InitUniforms(OceanMaterial);
OldLocalToOcean = Matrix4x4d.identity;
Offset = Vector4.zero;
// Create the projected grid. The resolution is the size in pixels of each square in the grid.
// If the squares are small the size of the mesh will exceed the max verts for a mesh in Unity. In this case split the mesh up into smaller meshes.
Resolution = Mathf.Max(1, Resolution);
// The number of squares in the grid on the x and y axis
var NX = Screen.width / Resolution;
var NY = Screen.height / Resolution;
var numGrids = 1;
const int MAX_VERTS = 65000;
// The number of meshes need to make a grid of this resolution
if (NX * NY > MAX_VERTS)
{
numGrids += (NX * NY) / MAX_VERTS;
}
ScreenMeshGrids = new Mesh[numGrids];
// Make the meshes. The end product will be a grid of verts that cover the screen on the x and y axis with the z depth at 0.
// This grid is then projected as the ocean by the shader
for (byte i = 0; i < numGrids; i++)
{
NY = Screen.height / numGrids / Resolution;
ScreenMeshGrids[i] = MeshFactory.MakeOceanPlane(NX, NY, (float)i / (float)numGrids, 1.0f / (float)numGrids);
ScreenMeshGrids[i].bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
}
}
public GeometryModel3D GenerateInteractionDiagram(Column column, Color color)
{
double scaleXYZ = 10;
Console.WriteLine("MaxMX = {0}, MaxMy = {1}, MaxP = {2}", batchDesign.MaxMx, batchDesign.MaxMy, batchDesign.MaxP);
List <Point3D> normalPoints = column.diagramVertices.Select(x => new Point3D(x.X / BatchDesign.MaxMx, x.Y / BatchDesign.MaxMy, -x.Z / BatchDesign.MaxP)).ToList();
normalPoints = normalPoints.Select(x => new Point3D(scaleXYZ * x.X, scaleXYZ * x.Y, scaleXYZ * x.Z)).ToList();
var meshBuilder = new MeshBuilder(false, true);
for (int i = 0; i < normalPoints.Count; i++)
{
Point3D pt = normalPoints[i];
meshBuilder.Positions.Add(pt);
meshBuilder.TextureCoordinates.Add(new Point());
}
for (int i = 0; i < column.diagramFaces.Count; i++)
{
var t = column.diagramFaces[i];
meshBuilder.AddTriangle(new List <int> {
column.diagramVertices.IndexOf(t.Points[0]),
column.diagramVertices.IndexOf(t.Points[1]),
column.diagramVertices.IndexOf(t.Points[2])
});
meshBuilder.AddCylinder(normalPoints[column.diagramVertices.IndexOf(t.Points[0])],
normalPoints[column.diagramVertices.IndexOf(t.Points[1])], 0.05, 8);
meshBuilder.AddCylinder(normalPoints[column.diagramVertices.IndexOf(t.Points[1])],
normalPoints[column.diagramVertices.IndexOf(t.Points[2])], 0.05, 8);
meshBuilder.AddCylinder(normalPoints[column.diagramVertices.IndexOf(t.Points[0])],
normalPoints[column.diagramVertices.IndexOf(t.Points[2])], 0.05, 8);
}
//var mat = new DiffuseMaterial(GradientBrushes.BlueWhiteRed);
var mesh = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(color));
mesh.BackMaterial = mesh.Material;
return(mesh);
}
/// <summary>
/// Shows the and hang transparents and solids.
/// </summary>
/// <param name="transparents">The transparents.</param>
/// <param name="solids">The solids.</param>
public static void ShowAndHangTransparentsAndSolids(IList <TessellatedSolid> transparents, IList <TessellatedSolid> solids)
{
var window = new Window3DPlot();
foreach (var ts in solids)
{
window.view1.Children.Add(MakeModelVisual3D(ts));
}
foreach (var ts in transparents)
{
var positions =
ts.Faces.SelectMany(
f => f.Vertices.Select(v => new Point3D(v.Position[0], v.Position[1], v.Position[2])));
var normals =
ts.Faces.SelectMany(f => f.Vertices.Select(v => new Vector3D(f.Normal[0], f.Normal[1], f.Normal[2])));
var r = ts.SolidColor.R;
var g = ts.SolidColor.G;
var b = ts.SolidColor.B;
window.view1.Children.Add(
new ModelVisual3D
{
Content =
new GeometryModel3D
{
Geometry = new MeshGeometry3D
{
Positions = new Point3DCollection(positions),
Normals = new Vector3DCollection(normals)
},
Material = MaterialHelper.CreateMaterial(new System.Windows.Media.Color {
A = 120, R = r, G = g, B = b
})
}
});
}
window.view1.FitView(window.view1.Camera.LookDirection, window.view1.Camera.UpDirection);
window.ShowDialog();
}
private void SetGeometry(string model)
{
Model3DGroup device = null;
try
{
//Import 3D model file
ModelImporter import = new ModelImporter();
System.Windows.Media.Media3D.Material mat = MaterialHelper.CreateMaterial(
//new SolidColorBrush(Colors.SaddleBrown));
new SolidColorBrush(Colors.Pink));
import.DefaultMaterial = mat;
//Load the 3D model file
device = import.Load(model);
}
catch (Exception e)
{
// Handle exception in case can not file 3D model
MessageBox.Show("Exception Error : " + e.StackTrace);
}
Visual3DModel = device;
}
