public Trackball()
{
_yawRotation.Axis = new Vector3D(0, 1, 0);
_pitchRotation.Axis = new Vector3D(1, 0, 0);
_transform = new Transform3DGroup();
_transform.Children.Add(new RotateTransform3D(_yawRotation));
_transform.Children.Add(new RotateTransform3D(_pitchRotation));
_yawInertia.ValueChanged = Yaw;
_pitchInertia.ValueChanged = Pitch;
}
private void ChangeReference(ModelVisual3D m, Transform3D source, Transform3D destination)
{
var tg = new Transform3DGroup();
tg.Children.Add(m.Transform);
tg.Children.Add(source);
tg.Children.Add(destination.Invert());
m.Transform = new MatrixTransform3D(tg.Value);
}
public void UpdateTransform()
{
var tg = new Transform3DGroup();
// http://en.wikipedia.org/wiki/Argument_of_periapsis
// tg.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0,0,1),LongitudeOfAscendingNode)));
tg.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 1, 0), Inclination)));
// tg.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1,0,0),ArgumentOfPerihelion)));
Transform = tg;
}
public override CollisionHull CreateCollisionHull(WorldBase world)
{
Transform3DGroup transform = new Transform3DGroup();
//transform.Children.Add(new ScaleTransform3D(this.Scale)); // it ignores scale
transform.Children.Add(new RotateTransform3D(new QuaternionRotation3D(this.Orientation)));
transform.Children.Add(new TranslateTransform3D(this.Position.ToVector()));
return(CollisionHull.CreateBox(world, 0, this.Scale * ConverterMatterToFuelDesign.SCALE, transform.Value));
}
public Trackball(double rotationFactor = 4.0, double zoomFacfor = 1.0)
{
_rotationFactor = rotationFactor;
_zoomFactor = zoomFacfor;
_transform = new Transform3DGroup();
_transform.Children.Add(_scale);
_rotateTransform = new RotateTransform3D(_rotation);
_transform.Children.Add(_rotateTransform);
_transform.Children.Add(_translate);
}
private static Model3DGroup Leg(Material legMaterial, Material footMaterial)
{
// Create parts
MeshGeometry3D footMesh = MeshFactory.Sphere(4, 6, 1.1);
// MeshGeometry3D legMesh = MeshFactory.Spiral( 3, 8, 1.1, 2.2 );
MeshGeometry3D legMesh = MeshFactory.Sphere(8, 6, 1.1);
GeometryModel3D footModel = new GeometryModel3D(footMesh, footMaterial);
// Use the same material for front and back
footModel.BackMaterial = footMaterial;
GeometryModel3D topModel = new GeometryModel3D(legMesh, legMaterial);
// Use the same material for front and back
topModel.BackMaterial = legMaterial;
GeometryModel3D bottomModel = new GeometryModel3D(legMesh, legMaterial);
// Use the same material for front and back
bottomModel.BackMaterial = legMaterial;
// Create transforms for parts
Transform3DGroup legPieceTransform = new Transform3DGroup();
legPieceTransform.Children.Add(new TranslateTransform3D(new Vector3D(0, -1, 0)));
legPieceTransform.Children.Add(new ScaleTransform3D(new Vector3D(.1, .3, .1), new Point3D()));
Transform3DGroup footPieceTransform = new Transform3DGroup();
footPieceTransform.Children.Add(new TranslateTransform3D(new Vector3D(0, -1, 0.5)));
footPieceTransform.Children.Add(new ScaleTransform3D(new Vector3D(.2, .1, .3), new Point3D()));
// Create groups
Model3DGroup legJoint = new Model3DGroup();
Model3DGroup knee = new Model3DGroup();
Model3DGroup kneeJoint = new Model3DGroup();
Model3DGroup ankle = new Model3DGroup();
Model3DGroup ankleJoint = new Model3DGroup();
// mix and match transforms to pieces ...
footModel.Transform = footPieceTransform;
ankleJoint.Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), -20));
ankleJoint.Children.Add(footModel);
ankle.Transform = new TranslateTransform3D(new Vector3D(0, -.6, 0));
ankle.Children.Add(ankleJoint);
bottomModel.Transform = legPieceTransform;
kneeJoint.Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), 40));
kneeJoint.Children.Add(ankle); // always add groups first
kneeJoint.Children.Add(bottomModel);
knee.Transform = new TranslateTransform3D(new Vector3D(0, -.6, 0));
knee.Children.Add(kneeJoint);
topModel.Transform = legPieceTransform;
legJoint.Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), -20));
legJoint.Children.Add(knee); // always add groups first
legJoint.Children.Add(topModel);
return(legJoint);
}
// Define the model.
private void DefineModel(Model3DGroup group)
{
// Axes.
//MeshExtensions.AddAxes(group);
// Make the generator.
int numPoints = 20;
Point3D[] generator = G3.MakePolygonPoints(numPoints,
new Point3D(2, 0, 0),
D3.XVector(2), D3.ZVector(2));
numPoints++;
Array.Resize(ref generator, numPoints);
generator[numPoints - 1] = generator[0];
// Make the transformation.
Transform3DGroup transGroup = new Transform3DGroup();
transGroup.Children.Add(new ScaleTransform3D(0.95, 0.95, 0.95));
transGroup.Children.Add(new TranslateTransform3D(0, 0, 0.17));
transGroup.Children.Add(D3.Rotate(D3.ZVector(), D3.Origin, -20));
// Make the surface of transformation.
const int numTrans = 100;
MeshGeometry3D mesh1 = new MeshGeometry3D();
mesh1.AddTransformSurface(generator, transGroup, numTrans,
false, false, false, false,
false);
TranslateTransform3D trans = new TranslateTransform3D(0, 1, 0);
mesh1.ApplyTransformation(trans);
GeometryModel3D model = mesh1.MakeModel(Brushes.LightBlue);
model.BackMaterial = model.Material;
group.Children.Add(model);
// Make a wireframe.
HashSet <Edge> edges = new HashSet <Edge>();
MeshGeometry3D mesh2 = new MeshGeometry3D();
mesh2.AddTransformSurface(generator, transGroup, numTrans,
false, false, false, false,
false, edges, 0.02);
mesh2.ApplyTransformation(trans);
group.Children.Add(mesh2.MakeModel(Brushes.Blue));
// Display the generator.
edges = new HashSet <Edge>();
MeshGeometry3D mesh3 = new MeshGeometry3D();
mesh3.AddPolygonEdges(edges, 0.1, generator);
mesh3.ApplyTransformation(trans);
group.Children.Add(mesh3.MakeModel(Brushes.Blue));
}
/// <summary>
///
/// </summary>
public void Initialise(ILayer baseLayer)
{
#region Construct View Port , Add Transforms, Scale
Viewport3D viewport = ViewPort;
_transform = new Transform3DGroup();
_transform.Children.Add(_scale);
_rotationTranform = new RotateTransform3D(_rotation);
_transform.Children.Add(_rotationTranform);
AmbientLight _ambLight = new AmbientLight(System.Windows.Media.Brushes.White.Color);
var visuald = new ModelVisual3D();
Model3DGroup M3dG = new Model3DGroup();
M3dG.Children.Add(_ambLight);
visuald.Content = M3dG;
viewport.Children.Add(visuald);
#endregion
BaseLayer = baseLayer;
this.RootTile = new GlobeTile(0, 0, 0, visuald);
var root = this.RootTile;
this.RootTile.zoomIn();
//Map Viewport as Event Source to Map Event Handlers.
EventSource = viewport;
//Add All Necessary Transforms to view port Camera.
viewport.Camera.Transform = _transform;
#region Populate Initial Layer [Based on MS Bing Map]
var initialKey = "032010110132012031";//initial key
for (var i = 0; i < initialKey.Length; i++)
{
root.Children[int.Parse(initialKey.Substring(i, 1))].zoomIn();
}
#endregion
#region Map Events to Handelers
viewport.MouseDown += viewport_MouseDown;
viewport.MouseUp += viewport_MouseUp;
viewport.MouseMove += viewport_MouseMove;
viewport.MouseWheel += viewport_MouseWheel;
viewport.SizeChanged += viewport_SizeChanged;
#endregion
RedrawSphere();
}
public Creature(Point3D position, Creature mother, Creature father)
{
Mother = mother;
Father = father;
Gender = randomizer.Next(2) == 0 ? Gender.Male : Gender.Female;
Position = position;
Heading = 0;
Speed = 0;
AngularSpeed = 0;
Acceleration = 0;
BirthTime = GetRandom(5, 3);
ChildhoodDuration = GetRandom(20, 10);
LifeTime = GetRandom(90, 30);
PrivacyDist = 2.5;
double bmiMean = 25;
double maxSpeedMean = 3;
double heightMean = 1.75;
if (mother != null)
{
heightMean = (Mother.GrownupHeight + Father.GrownupHeight) / 2;
bmiMean = (Mother.BMI + Father.BMI) / 2;
maxSpeedMean = (Mother.MaxSpeed + Father.MaxSpeed) / 2;
}
BMI = GetRandom(bmiMean, bmiMean / 2);
GrownupHeight = GetRandom(heightMean, 0.5);
MaxSpeed = Gender == Gender.Male ? GetRandom(maxSpeedMean + 2, 1) : GetRandom(maxSpeedMean, 1);
Agility = GetRandom(15, 10);
Fitness = GetRandom(1, 0.5);
Energy = 1;
model = new GeometryModel3D();
translation = new TranslateTransform3D();
scale = new ScaleTransform3D();
var rotationT = new RotateTransform3D();
rotation = new AxisAngleRotation3D(new Vector3D(0, 0, 1), 0);
rotationT.Rotation = rotation;
scale.ScaleX = 1;
scale.ScaleY = 1;
scale.ScaleZ = 1;
var tg = new Transform3DGroup();
tg.Children.Add(scale);
tg.Children.Add(rotationT);
tg.Children.Add(translation);
model.Transform = tg;
Content = model;
}
private void init3D()
{
// Define 3D mesh object
//arrowMesh = new MeshGeometry3D();
//arrowMesh.Positions.Add(new Point3D(-0.5, -0.25, 0));
////arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
//arrowMesh.Positions.Add(new Point3D(1, 0, 0));
////arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
//arrowMesh.Positions.Add(new Point3D(-0.5, 0.25, 0));
////arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
arrowMesh.Positions.Add(new Point3D(-0.25, -0.4, 0));
//arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
arrowMesh.Positions.Add(new Point3D(0.25, -0.4, 0));
//arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
arrowMesh.Positions.Add(new Point3D(0, 0.4, 0));
//arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
// Front face
arrowMesh.TriangleIndices.Add(0);
arrowMesh.TriangleIndices.Add(1);
arrowMesh.TriangleIndices.Add(2);
arrowMesh.TriangleIndices.Add(2);
arrowMesh.TriangleIndices.Add(1);
arrowMesh.TriangleIndices.Add(0);
squareMesh.Positions.Add(new Point3D(-0.4, -0.4, 0));
//arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
squareMesh.Positions.Add(new Point3D(0.4, -0.4, 0));
//arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
squareMesh.Positions.Add(new Point3D(0.4, 0.4, 0));
//arrowMesh.Normals.Add(new Vector3D(0, 0, 1));
squareMesh.Positions.Add(new Point3D(-0.4, 0.4, 0));
// Front face
squareMesh.TriangleIndices.Add(0);
squareMesh.TriangleIndices.Add(1);
squareMesh.TriangleIndices.Add(2);
squareMesh.TriangleIndices.Add(0);
squareMesh.TriangleIndices.Add(2);
squareMesh.TriangleIndices.Add(3);
//Sets up transformation of the group
Transform3DGroup gr = new Transform3DGroup();
model.Transform = gr;
}
private static Visual3D GetColorWheel(double[] hues, double stepAngle)
{
//const double CONE_RADIUS = CIRCLE_MINORRADIUS * .6667;
const double CONE_RADIUS = CIRCLE_MINORRADIUS * 1.5;
const double CONE_HEIGHT1 = CIRCLE_MAJORRADIUS * .25;
const double CONE_HEIGHT2 = CIRCLE_MAJORRADIUS * .1;
const int SEGMENTS = 8;
Model3DGroup group = new Model3DGroup();
for (int cntr = 0; cntr < hues.Length; cntr++)
{
#region In facing cone
// Material
MaterialGroup materials = new MaterialGroup();
materials.Children.Add(UtilityWPF.GetUnlitMaterial(new ColorHSV(hues[cntr], 75, 75).ToRGB()));
// Geometry Model
GeometryModel3D geometry = new GeometryModel3D();
geometry.Material = materials;
geometry.BackMaterial = materials;
geometry.Geometry = UtilityWPF.GetCone_AlongX(SEGMENTS, CONE_RADIUS, CONE_HEIGHT1);
Transform3DGroup transform = new Transform3DGroup();
transform.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), 180)));
transform.Children.Add(new TranslateTransform3D(CIRCLE_MAJORRADIUS - (CONE_HEIGHT1 / 2), 0, 0));
transform.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), stepAngle * cntr)));
geometry.Transform = transform;
group.Children.Add(geometry);
#endregion
#region Out facing cone
// Geometry Model
geometry = new GeometryModel3D();
geometry.Material = materials;
geometry.BackMaterial = materials;
geometry.Geometry = UtilityWPF.GetCone_AlongX(SEGMENTS, CONE_RADIUS, CONE_HEIGHT2);
transform = new Transform3DGroup();
transform.Children.Add(new TranslateTransform3D(CIRCLE_MAJORRADIUS + (CONE_HEIGHT2 / 2), 0, 0));
transform.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), stepAngle * cntr)));
geometry.Transform = transform;
group.Children.Add(geometry);
#endregion
}
ModelVisual3D visual = new ModelVisual3D();
visual.Content = group;
return(visual);
}
private void SurfaceView_MouseLeave(object sender, MouseEventArgs e)
{
if (Mouse.LeftButton == MouseButtonState.Pressed)
{
var diff = e.GetPosition(this) - pre_point;
var size = Math.Min(this.ActualWidth, this.ActualHeight);
double x = diff.X / size * 100;
double y = -diff.Y / size * 100;
Transform3DGroup transform3DGroup = new Transform3DGroup();
if (viewMode == 1)
{
transform = new Vector3D(x + transform.X, transform.Y, y + transform.Z);
transform3DGroup.Children.Add(new RotateTransform3D(new QuaternionRotation3D(quaternion)));
transform3DGroup.Children.Add(new TranslateTransform3D(transform.X, 0, transform.Z));
model.Transform = transform3DGroup;
}
if (viewMode == 2)
{
var q = quaternion;
q.Invert();
x /= 5;
y /= 5;
Point3D p = (new RotateTransform3D(new QuaternionRotation3D(q))).Transform(new Point3D(x, 0, y));
transform = new Vector3D(p.X + transform.X, p.Y + transform.Y, p.Z + transform.Z);
transform3DGroup.Children.Add(new TranslateTransform3D(transform));
transform3DGroup.Children.Add(new RotateTransform3D(new QuaternionRotation3D(quaternion)));
model.Transform = transform3DGroup;
}
left_click = false;
}
if (Mouse.RightButton == MouseButtonState.Pressed)
{
var diff = e.GetPosition(this) - pre_point;
var size = Math.Min(this.ActualWidth, this.ActualHeight);
double x = 360 * diff.X / size;
double y = 360 * diff.Y / size;
var q = new Quaternion(new Vector3D(0, 0, 1), x);
q *= new Quaternion(new Vector3D(1, 0, 0), y);
quaternion = q * quaternion;
Transform3DGroup transform3DGroup = new Transform3DGroup();
if (viewMode == 1)
{
transform3DGroup.Children.Add(new RotateTransform3D(new QuaternionRotation3D(quaternion)));
transform3DGroup.Children.Add(new TranslateTransform3D(transform.X, 0, transform.Z));
model.Transform = transform3DGroup;
}
if (viewMode == 2)
{
transform3DGroup.Children.Add(new TranslateTransform3D(transform));
transform3DGroup.Children.Add(new RotateTransform3D(new QuaternionRotation3D(quaternion)));
model.Transform = transform3DGroup;
}
right_click = false;
}
}
public Cube(Viewport3D myViewport3D, float obesity)
{
this.up = ((PerspectiveCamera)myViewport3D.Camera).UpDirection;
this.trans = new Transform3DGroup();
this.scale = new ScaleTransform3D();
this.translation = new TranslateTransform3D();
this.rotation = new RotateTransform3D();
this.axis = new AxisAngleRotation3D();
this.obesity = obesity;
this.cube = new Model3DGroup();
Point3D p0 = new Point3D(-1, -1, -1);
Point3D p1 = new Point3D(1, -1, -1);
Point3D p2 = new Point3D(1, -1, 1);
Point3D p3 = new Point3D(-1, -1, 1);
Point3D p4 = new Point3D(-1, 0, -1);
Point3D p5 = new Point3D(1, 0, -1);
Point3D p6 = new Point3D(1, 0, 1);
Point3D p7 = new Point3D(-1, 0, 1);
//front side triangles
cube.Children.Add(CreateTriangleModel(p3, p2, p6));
cube.Children.Add(CreateTriangleModel(p3, p6, p7));
//right side triangles
cube.Children.Add(CreateTriangleModel(p2, p1, p5));
cube.Children.Add(CreateTriangleModel(p2, p5, p6));
//back side triangles
cube.Children.Add(CreateTriangleModel(p1, p0, p4));
cube.Children.Add(CreateTriangleModel(p1, p4, p5));
//left side triangles
cube.Children.Add(CreateTriangleModel(p0, p3, p7));
cube.Children.Add(CreateTriangleModel(p0, p7, p4));
//top side triangles
cube.Children.Add(CreateTriangleModel(p7, p6, p5));
cube.Children.Add(CreateTriangleModel(p7, p5, p4));
//bottom side triangles
cube.Children.Add(CreateTriangleModel(p2, p3, p0));
cube.Children.Add(CreateTriangleModel(p2, p0, p1));
this.model = new ModelVisual3D();
this.model.Content = cube;
this.myDirectionalLight = new DirectionalLight();
this.myDirectionalLight.Color = Colors.Green;
this.myDirectionalLight.Direction = new Vector3D(-2, -3, 1);
this.cube.Children.Add(myDirectionalLight);
myViewport3D.Children.Add(model);
trans.Children.Add(scale);
trans.Children.Add(rotation);
trans.Children.Add(translation);
this.cube.Transform = trans;
}
public MainViewModel2(IHelixViewport3D viewPort)
{
_viewport = viewPort;
_traslateTrasform = new TranslateTransform3D();
_traslateTrasform2 = new TranslateTransform3D();
_trasformGroup = new Transform3DGroup();
_trasformGroup.Children.Add(_traslateTrasform);
_trasformGroup.Children.Add(_traslateTrasform2);
}
public MainWindow()
{
InitializeComponent();
// add the starfield to the background
ModelVisual3D starfield = new StarfieldModel3D();
starfield.Transform = StarfieldRotMatrix;
Viewport.Children.Add(starfield);
// add standard light sources
Viewport.Children.Add(new ModelVisual3D()
{
Content = AmbientLight
});
Viewport.Children.Add(new ModelVisual3D()
{
Content = DirectionalLight
});
// add the playfield model
ModelVisual3D playfield = PlayfieldModel;
Transform3DGroup xform_group = new Transform3DGroup();
xform_group.Children.Add(ModelRotate);
xform_group.Children.Add(ModelTranslate);
xform_group.Children.Add(ModelScale);
playfield.Transform = xform_group;
Viewport.Children.Add(playfield);
#if DEBUG
// throw in big brother
if (MathboxModel3D.TryGetModel(Mathbox.Mesh.BIG_BROTHER_MOUTH_CLOSED, out var big_bro))
{
ModelVisual3D b = new ModelVisual3D();
b.Content = big_bro;
b.Transform = xform_group;
Viewport.Children.Add(b);
}
#endif
// populate the list view with available levels
foreach (var level in Levels)
{
lbLevels.Items.Add(level);
}
lbLevels.SelectedIndex = 0;
// start our timer
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromSeconds(0.05);
timer.Tick += timer_Tick;
timer.Start();
}
private void MakeObjects(out MeshGeometry3D cameraMesh,
out MeshGeometry3D boxMesh, out MeshGeometry3D edgeMesh,
out Point3D cameraCenter)
{
// Make a "camera."
cameraMesh = new MeshGeometry3D();
cameraMesh.AddBox(new Point3D(-0.6, -0.5, -0.2),
D3.XVector(1.2), D3.YVector(1), D3.ZVector(0.4));
Point3D[] points = G3.MakePolygonPoints(20, new Point3D(0, 0, -0.7),
D3.XVector(0.3), D3.YVector(0.3));
cameraMesh.AddCylinder(points, D3.ZVector(0.7), true);
points = G3.MakePolygonPoints(20, new Point3D(0, 0, -0.8),
D3.XVector(0.4), D3.YVector(0.4));
cameraMesh.AddCylinder(points, D3.ZVector(0.2), true);
cameraMesh.AddBox(new Point3D(0.3, 0.5, -0.1),
D3.XVector(0.2), D3.YVector(0.2), D3.ZVector(0.2));
MainGroup.Children.Add(cameraMesh.MakeModel(Brushes.LightBlue));
// Transform the camera and vector.
Transform3DGroup trans = new Transform3DGroup();
RotateTransform3D r1 = D3.Rotate(D3.XVector(), D3.Origin, -45);
trans.Children.Add(r1);
RotateTransform3D r2 = D3.Rotate(D3.YVector(), D3.Origin, -45);
trans.Children.Add(r2);
// See where we need to translate to make the camera point at the origin.
Point3D lookAtPoint = new Point3D(0, 0, -3.5);
lookAtPoint = trans.Transform(lookAtPoint);
TranslateTransform3D t1 = new TranslateTransform3D(
-lookAtPoint.X, -lookAtPoint.Y, -lookAtPoint.Z);
trans.Children.Add(t1);
cameraMesh.ApplyTransformation(trans);
cameraCenter = trans.Transform(D3.Origin);
// Make a target box.
boxMesh = new MeshGeometry3D();
boxMesh.AddBox(new Point3D(-0.75, -0.75, -0.75),
D3.XVector(1.5), D3.YVector(1.5), D3.ZVector(1.5));
MainGroup.Children.Add(boxMesh.MakeModel(Brushes.LightGreen));
// Make the box's edges.
edgeMesh = new MeshGeometry3D();
HashSet <Edge> edges = new HashSet <Edge>();
edgeMesh.AddBox(new Point3D(-0.75, -0.75, -0.75),
D3.XVector(1.5), D3.YVector(1.5), D3.ZVector(1.5), edges: edges);
MainGroup.Children.Add(edgeMesh.MakeModel(Brushes.Black));
}
private void Grid_MouseWheel(object sender, MouseWheelEventArgs e)
{
Vector3D lookAt = camera.LookDirection;
//lookAt.Negate () ;
lookAt.Normalize();
lookAt *= e.Delta / zoomDeltaFactor;
Transform3DGroup transformGroup = camera.Transform as Transform3DGroup;
transformGroup.Children.Add(new TranslateTransform3D(lookAt));
}
/// <summary>
/// This isn't a good way of manipulating the camera
/// </summary>
private void RotateCameraUsingTransform(double dx, double dy)
{
// Turn the mouse movement into 3D rotation
Quaternion quat = GetSphericalMovement(dx, dy);
Transform3DGroup transform = _camera1.Transform as Transform3DGroup;
RotateTransform3D rotation = new RotateTransform3D(new AxisAngleRotation3D(quat.Axis, quat.Angle * -1d));
transform.Children.Add(rotation);
}
private void Update(DataSet.EnsembleVelocityVectors vectors)
{
int width = _maxEnsembles; // Max number of ensembles
int height = vectors.Vectors.Length; // Number of bins in the vector array
// If this is the first entry
// The plot needs to be created
// Need to know the number of bins to create the arrays
if (_isNewPlot)
{
CreatePlot(width, height);
}
// Create a 3d point based off each magnitude in the vector
for (int bin = 0; bin < vectors.Vectors.Length; bin++)
{
// Get the magnitude
double mag = vectors.Vectors[bin].Magnitude;
// Set the color based off the magnitude
Material material = MaterialHelper.CreateMaterial(GenerateColor(mag));
// Check if the magnitude is bad
// If its bad, set the height to 0
if (mag != DataSet.Ensemble.BAD_VELOCITY)
{
ScaleTransforms[_ens, bin] = new ScaleTransform3D(1, 1, mag);
}
else
{
ScaleTransforms[_ens, bin] = new ScaleTransform3D(1, 1, 0);
}
var translation = new TranslateTransform3D((bin - (height - 1) * 0.5) * Distance, _ens * Distance, 0);
var tg = new Transform3DGroup();
tg.Children.Add(ScaleTransforms[_ens, bin]);
tg.Children.Add(translation);
Models[_ens, bin] = new GeometryModel3D(Geometry, material)
{
Transform = tg
};
((Model3DGroup)Content).Children.Add(Models[_ens, bin]);
}
if (_ens + 1 < _maxEnsembles)
{
_ens++;
}
else
{
ShiftPlot(width, height);
RemoveFirstEnsemble(height);
}
}
private ScaleTransform3D GetScaleTransform3D(Visual3D visual3D, bool ensureScaleTransform3D = true)
{
var scaleTransform3D = visual3D.Transform as ScaleTransform3D;
if (scaleTransform3D != null)
{
return(scaleTransform3D);
}
if (visual3D.Transform == null)
{
if (ensureScaleTransform3D)
{
scaleTransform3D = new ScaleTransform3D();
visual3D.Transform = scaleTransform3D;
}
else
{
scaleTransform3D = null;
}
}
else
{
var transformGroup = visual3D.Transform as Transform3DGroup;
if (transformGroup != null)
{
if (ensureScaleTransform3D)
{
scaleTransform3D = new ScaleTransform3D();
transformGroup.Children.Insert(0, scaleTransform3D); // Insert scale transform before other transformations (especially before translate because if translete is before scale, then scale also scales the translate amount)
}
else
{
scaleTransform3D = null;
}
}
else
{
if (ensureScaleTransform3D)
{
scaleTransform3D = new ScaleTransform3D();
var transform3DGroup = new Transform3DGroup();
transform3DGroup.Children.Add(scaleTransform3D);
transform3DGroup.Children.Add(visual3D.Transform);
visual3D.Transform = transform3DGroup;
}
}
}
return(scaleTransform3D);
}
private void Grid_MouseMove(object sender, MouseEventArgs e)
{
if (!mDown)
{
return;
}
Point pos = Mouse.GetPosition(mViewPort);
Point actualPos = new Point(pos.X - mViewPort.ActualWidth / 2, mViewPort.ActualHeight / 2 - pos.Y);
//double dx = actualPos.X - mLastPos.X;
double dx = mLastPos.X - actualPos.X;
double dy = actualPos.Y - mLastPos.Y;
double mouseAngle = 0;
if (dx != 0 && dy != 0)
{
mouseAngle = Math.Asin(Math.Abs(dy) / Math.Sqrt(dx * dx + dy * dy));
if (dx < 0 && dy > 0)
{
mouseAngle += Math.PI / 2;
}
else if (dx < 0 && dy < 0)
{
mouseAngle += Math.PI;
}
else if (dx > 0 && dy < 0)
{
mouseAngle += Math.PI * 1.5;
}
}
else if (dx == 0 && dy != 0)
{
mouseAngle = Math.Sign(dy) > 0 ? Math.PI / 2 : Math.PI * 1.5;
}
else if (dx != 0.0 && dy == 0.0)
{
mouseAngle = Math.Sign(dx) > 0 ? 0.0 : Math.PI;
}
double axisAngle = mouseAngle + Math.PI / 2;
Vector3D axis = new Vector3D(Math.Cos(axisAngle) * 4.0, Math.Sin(axisAngle) * 4.0, 0.0);
double rotation = 0.02 * Math.Sqrt(dx * dx + dy * dy);
Transform3DGroup group = mGeometryModel.Transform as Transform3DGroup;
QuaternionRotation3D r = new QuaternionRotation3D(new Quaternion(axis, rotation * 180.0 / Math.PI));
group.Children.Add(new RotateTransform3D(r));
mLastPos = actualPos;
}
private void Home_Click(object sender, RoutedEventArgs e)
{
if (e != null)
{
e.Handled = true;
}
Transform3DGroup transformGroup = camera.Transform as Transform3DGroup;
transformGroup.Children.Clear();
}
private void update_models()
{
Transform3DGroup transform_joint1 = new Transform3DGroup();
Transform3DGroup transform_joint2 = new Transform3DGroup();
Transform3DGroup transform_joint3 = new Transform3DGroup();
Transform3DGroup transform_position1 = new Transform3DGroup();
Transform3DGroup transform_position2 = new Transform3DGroup();
Translation = new TranslateTransform3D(Convert.ToDouble(coordinate_x.Text) - 40, Convert.ToDouble(coordinate_y.Text) - 30, Convert.ToDouble(coordinate_z.Text) - 10);
transform_position1.Children.Add(Translation);
Translation = new TranslateTransform3D(Convert.ToDouble(coordinate_end_x.Text) - 40, Convert.ToDouble(coordinate_end_y.Text) - 30, Convert.ToDouble(coordinate_end_z.Text) - 10);
transform_position2.Children.Add(Translation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), 90), new Point3D(0, 0, 0));
transform_position1.Children.Add(Rotation);
transform_position2.Children.Add(Rotation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), 90), new Point3D(0, 0, 0));
transform_joint1.Children.Add(Rotation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), joint1), new Point3D(17.5, -30, 0));
transform_joint1.Children.Add(Rotation);
Translation = new TranslateTransform3D(0, 182.5, 0);
transform_joint2.Children.Add(Translation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 1, 0), 90), new Point3D(0, 0, 0));
transform_joint2.Children.Add(Rotation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), joint2), new Point3D(0, 200, 0));
transform_joint2.Children.Add(Rotation);
transform_joint2.Children.Add(transform_joint1);
Translation = new TranslateTransform3D(100, 0, 0);
transform_joint3.Children.Add(Translation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), 0), new Point3D(0, 0, 0));
transform_joint3.Children.Add(Rotation);
Rotation = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), joint3), new Point3D(100, 17.5, 0));
transform_joint3.Children.Add(Rotation);
transform_joint3.Children.Add(transform_joint2);
positionmodel.Transform = transform_position1;
positionmodel2.Transform = transform_position2;
arm_link1.Transform = transform_joint1;
arm_link2.Transform = transform_joint2;
arm_link3.Transform = transform_joint3;
}
public Trackball()
{
_transform = new Transform3DGroup();
_transform.Children.Add(_scale);
_transform.Children.Add(new RotateTransform3D(_rotation));
_currentOrientation = Quaternion.Identity;
_persistentOrientation = Quaternion.Identity;
IoC.Get <IPropertyGrid>().SelectedObject = _rotation;
}
public Window1()
{
this.InitializeComponent();
cameraX = ppc.Position.X;
cameraY = ppc.Position.Y;
cameraZ = ppc.Position.Z;
//声明或获取当前World的三维变换组（xaml中）Transform3DGroup
GroupTF3D = World.Transform as Transform3DGroup;
//记录三维变换组中子变换的总数
transforms = GroupTF3D.Children.Count;
}
private Transform3D ReadTransformation(Dictionary <string, object> settings)
{
Transform3DGroup trgr = new Transform3DGroup();
if (settings.ContainsKey("transformation_order") && !string.IsNullOrWhiteSpace((string)settings["transformation_order"]))
{
var order = ((string)settings["transformation_order"]).ToLower().Distinct();
int count = 0;
foreach (var symbol in order)
{
if (symbol == 's')
{
if (settings.ContainsKey("scale"))
{
var transform = GetTransformationFromString("scale", (string)settings["scale"]);
if (transform != null)
{
trgr.Children.Add(transform);
}
}
count++;
}
else if (symbol == 't')
{
if (settings.ContainsKey("translate"))
{
var transform = GetTransformationFromString("translate", (string)settings["translate"]);
if (transform != null)
{
trgr.Children.Add(transform);
}
}
count++;
}
else if (symbol == 'r')
{
if (settings.ContainsKey("rotate"))
{
var transform = GetTransformationFromString("rotate", (string)settings["rotate"]);
if (transform != null)
{
trgr.Children.Add(transform);
}
}
count++;
}
if (count == 3)
{
break;
}
}
}
return(trgr);
}
public void SetModel(Mesh3D mesh)
{
// Add the mesh.
myGeometryModel = new GeometryModel3D();
MeshGeometry3D myMeshGeometry3D = new MeshGeometry3D();
Point3DCollection myPositionCollection = new Point3DCollection();
Int32Collection myTriangleIndicesCollection = new Int32Collection();
try
{
for (int i = 0; i < mesh.Vertices.Length; i++)
{
myPositionCollection.Add(new Point3D(mesh.Vertices[i].x, mesh.Vertices[i].y, mesh.Vertices[i].z));
}
myTriangleIndicesCollection = new Int32Collection(mesh.Triangles);
}
catch (Exception ex)
{
}
myMeshGeometry3D.Positions = myPositionCollection;
myMeshGeometry3D.TriangleIndices = myTriangleIndicesCollection;
// Apply the mesh to the geometry model.
myGeometryModel.Geometry = myMeshGeometry3D;
// Define material and apply to the mesh geometries.
Material myMaterial;
//if (this.renderType == RenderAspectEnum.GreenLimeYellow)
// myMaterial = new DiffuseMaterial(new SolidColorBrush(Colors.LimeGreen));
//else
myMaterial = new DiffuseMaterial(new SolidColorBrush(Colors.White));
myGeometryModel.Material = myMaterial;
Transform3DGroup transformGroup = new Transform3DGroup();
transformGroup.Children.Add(new ScaleTransform3D(mesh.Scale, mesh.Scale, mesh.Scale));
transformGroup.Children.Add(new TranslateTransform3D(new Vector3D(-mesh.OffsetX * mesh.Scale, -mesh.OffsetY * mesh.Scale, -mesh.OffsetZ * mesh.Scale)));
myModel3DGroup.Transform = transformGroup;
// Add the geometry model to the model group.
myModel3DGroup.Children.Add(myGeometryModel);
float newScale = mesh.Scale < 0.001 ? mesh.Scale * 10 : (mesh.Scale > 0.1 ? mesh.Scale * 0.1f : mesh.Scale);
myGridLines.Width = 5000 * newScale;
myGridLines.Thickness = myGridLines.Width / 7000;
myGridLines.Length = myGridLines.Width;
myGridLines.MajorDistance = myGridLines.Width / 30;
myGridLines.MinorDistance = myGridLines.MajorDistance / 10;
myGridLines.Center = new Point3D(-3f * mesh.Scale + myGridLines.MajorDistance / 2f, 3f * mesh.Scale + myGridLines.MajorDistance / 2f, -27.5f * mesh.Scale);
}
public void Move(double offsetX, double offsetY, double offsetZ, double angle)
{
Transform3DGroup transform = new Transform3DGroup();
RotateTransform3D rotateTrans = new RotateTransform3D();
rotateTrans.Rotation = new AxisAngleRotation3D(new Vector3D(0, 1, 0), angle);
TranslateTransform3D translateTrans = new TranslateTransform3D(offsetX, offsetY, offsetZ);
transform.Children.Add(rotateTrans);
transform.Children.Add(translateTrans);
this.Transform = transform;
}
// Just going with a sphere for the physics
internal static CollisionHull CreateCameraCollisionHull(WorldBase world, Vector3D scale, Quaternion orientation, Point3D position)
{
Transform3DGroup transform = new Transform3DGroup();
//transform.Children.Add(new ScaleTransform3D(scale)); // it ignores scale
transform.Children.Add(new RotateTransform3D(new QuaternionRotation3D(orientation)));
transform.Children.Add(new TranslateTransform3D(position.ToVector()));
Vector3D size = new Vector3D(scale.X * SCALE * .5d, scale.Y * SCALE * .5d, scale.Z * SCALE * .5d);
return(CollisionHull.CreateSphere(world, 0, size, transform.Value));
}
private static void ApplyLinearPositionLinkAction(IMachineElementViewModel vm)
{
var tg = new Transform3DGroup();
tg.Children.Add(vm.Transform);
var link = vm.LinkToParent as LinearPositionViewModel;
var action = GetLinearPositionLinkAction(tg, vm.LinkToParent.Direction, link.Pos);
link.ValueChanged += (s, e) => action(e);
vm.Transform = tg;
}