public void UpdateAll() { if (_map == null || _map.Triangles == null) return; Model3DGroup group = Model as Model3DGroup; group.Children.Clear(); List<Face> faces = _map.Triangles; MeshBuilder builder = new MeshBuilder(); foreach (Face face in faces) { Point3D p1 = new Point3D(face.v1.x,face.v1.y,face.v1.z); Point3D p2 = new Point3D(face.v2.x,face.v2.y,face.v2.z); Point3D p3 = new Point3D(face.v3.x,face.v3.y,face.v3.z); if( !Clipping.DrawPoint(p1) || !Clipping.DrawPoint(p2) || !Clipping.DrawPoint(p3) ) { continue; } builder.AddTriangle(p1, p2, p3); } group.Children.Add(new GeometryModel3D(builder.ToMesh(), Materials.Gray)); }
MeshBuilder GenerateCurveTriangles(MeshBuilder meshBuilder, bool doubleTriangles = false) { int baseIndex = 0; int sizeX = 2; int sizeY = meshBuilder.Vertices.Count / 3 - 1; int vi = baseIndex; for (int y = 0; y < sizeY; y++, vi++) { for (int x = 0; x < sizeX; x++, vi++) { meshBuilder.AddTriangle (vi, vi + sizeX + 1, vi + 1); meshBuilder.AddTriangle (vi + 1, vi + sizeX + 1, vi + sizeX + 2); if (y == sizeY - 1) { meshBuilder.AddTriangle (vi + sizeX + 1, baseIndex + x, vi + sizeX + 2); meshBuilder.AddTriangle (baseIndex + x + 1, vi + sizeX + 2, baseIndex + x); } if (doubleTriangles) { meshBuilder.AddTriangle (vi + 1, vi + sizeX + 1, vi); meshBuilder.AddTriangle (vi + sizeX + 2, vi + sizeX + 1, vi + 1); if (y == sizeY - 1) { meshBuilder.AddTriangle (vi + sizeX + 2, baseIndex + x, vi + sizeX + 1); meshBuilder.AddTriangle (baseIndex + x, vi + sizeX + 2, baseIndex + x + 1); } } } } return meshBuilder; }
public override Mesh BuildMesh() { MeshBuilder meshBuilder = new MeshBuilder(); float heightInc = m_Height / m_HeightSegmentCount; //calculate the slope of the cylinder based on the height and difference between radii: Vector2 slope = new Vector2(m_RadiusEnd - m_RadiusStart, m_Height); slope.Normalize(); //build the rings: for (int i = 0; i <= m_HeightSegmentCount; i++) { //centre position of this ring: Vector3 centrePos = Vector3.up * heightInc * i; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; //interpolate between the radii: float radius = Mathf.Lerp(m_RadiusStart, m_RadiusEnd, (float)i / m_HeightSegmentCount); //build the ring: BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, radius, v, i > 0, Quaternion.identity, slope); } return meshBuilder.CreateMesh(); }
/// <summary> /// Builds a single quad based on a position offset and width and length vectors. /// </summary> /// <param name="meshBuilder">The mesh builder currently being added to.</param> /// <param name="offset">A position offset for the quad.</param> /// <param name="widthDir">The width vector of the quad.</param> /// <param name="lengthDir">The length vector of the quad.</param> public static void BuildQuad(MeshBuilder meshBuilder, Vector3 offset, Vector3 widthDir, Vector3 lengthDir) { Vector3 normal = Vector3.Cross(lengthDir, widthDir).normalized; meshBuilder.Vertices.Add(offset); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDir); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDir + widthDir); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + widthDir); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(normal); //we don't know how many verts the meshBuilder is up to, but we only care about the four we just added: int baseIndex = meshBuilder.Vertices.Count - 4; meshBuilder.AddTriangle(baseIndex, baseIndex + 1, baseIndex + 2); meshBuilder.AddTriangle(baseIndex, baseIndex + 2, baseIndex + 3); }
public static MeshBuilder GetOmniArrowMesh(MeshBuilder meshBuilder) { //MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, 0.5f, -0.5f), new Vector3(0f, 0f, -1f), new Vector3(-0.5f, 0.5f, -0.5f)); // TOP // clockwise triangle? MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, 0f, -1f), new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(-0.5f, 0.5f, -0.5f)); // LEFT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, 0f, -1f), new Vector3(0.5f, -0.5f, -0.5f), new Vector3(-0.5f, -0.5f, -0.5f)); // BOTTOM MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), new Vector3(0f, 0f, -1f), new Vector3(0.5f, 0.5f, -0.5f)); // RIGHT // Front: MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, 0f, 1f), new Vector3(0.5f, 0.5f, 0.5f), new Vector3(-0.5f, 0.5f, 0.5f)); // TOP // clockwise triangle? MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), new Vector3(0f, 0f, 1f), new Vector3(-0.5f, 0.5f, 0.5f)); // LEFT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), new Vector3(0f, 0f, 1f), new Vector3(-0.5f, -0.5f, 0.5f)); // BOTTOM MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, 0f, 1f), new Vector3(0.5f, -0.5f, 0.5f), new Vector3(0.5f, 0.5f, 0.5f)); // RIGHT // LEFT: MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(-1f, 0f, 0f), new Vector3(-0.5f, 0.5f, 0.5f)); // TOP // clockwise winding? MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(-1f, 0f, 0f)); // LEFT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(-0.5f, -0.5f, 0.5f), new Vector3(-1f, 0f, 0f)); // BOTTOM MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), new Vector3(-1f, 0f, 0f), new Vector3(-0.5f, -0.5f, 0.5f)); // RIGHT // Right: MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(1f, 0f, 0f), new Vector3(0.5f, 0.5f, -0.5f), new Vector3(0.5f, 0.5f, 0.5f)); // TOP // clockwise winding? MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), new Vector3(0.5f, 0.5f, -0.5f), new Vector3(1f, 0f, 0f)); // LEFT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), new Vector3(0.5f, -0.5f, -0.5f), new Vector3(1f, 0f, 0f)); // BOTTOM MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(1f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), new Vector3(0.5f, -0.5f, 0.5f)); // RIGHT // TOP: MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, 0.5f, 0.5f), new Vector3(0f, 1f, 0f), new Vector3(-0.5f, 0.5f, 0.5f)); // front MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), new Vector3(0f, 1f, 0f), new Vector3(-0.5f, 0.5f, -0.5f)); // left MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, 1f, 0f), new Vector3(0.5f, 0.5f, 0.5f), new Vector3(0.5f, 0.5f, -0.5f)); // right MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(0f, 1f, 0f), new Vector3(0.5f, 0.5f, -0.5f)); // back // BOTTOM: MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, -1f, 0f), new Vector3(0.5f, -0.5f, 0.5f), new Vector3(-0.5f, -0.5f, 0.5f)); // front MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, -1f, 0f), new Vector3(-0.5f, -0.5f, 0.5f), new Vector3(-0.5f, -0.5f, -0.5f)); // left MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), new Vector3(0f, -1f, 0f), new Vector3(0.5f, -0.5f, -0.5f)); // right MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0f, -1f, 0f), new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.5f, -0.5f, -0.5f)); // back return meshBuilder; }
public override Mesh BuildMesh() { // SIMPLE PLANE! MeshBuilder meshBuilder = new MeshBuilder(); BuildQuad (meshBuilder, new Vector3(-0.5f, 0.0f, 0.5f), Vector3.back, Vector3.right); // TOP return meshBuilder.CreateMesh (); }
void GenerateCubeMesh() { MeshBuilder meshBuilder = new MeshBuilder (); Vector3 upDir = Vector3.up * meshHeight; Vector3 rightDir = Vector3.right * meshWidth; Vector3 forwardDir = Vector3.forward * meshLength; Vector3 nearCorner = - 0.5f * (upDir + rightDir + forwardDir); Vector3 farCorner = nearCorner + upDir + rightDir + forwardDir; BuildQuad (meshBuilder, nearCorner, forwardDir, rightDir, sizeX, sizeZ); BuildQuad (meshBuilder, nearCorner, rightDir, upDir, sizeX, sizeZ); BuildQuad (meshBuilder, nearCorner, upDir, forwardDir, sizeX, sizeZ); BuildQuad (meshBuilder, farCorner, -rightDir, -forwardDir, sizeX, sizeZ); BuildQuad (meshBuilder, farCorner, -upDir, -rightDir, sizeX, sizeZ); BuildQuad (meshBuilder, farCorner, -forwardDir, -upDir, sizeX, sizeZ); GetComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); //Invoke ("Spherify", 3f); PrepareForVerticesAnimation (); }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); ////one-segment cylinder (build two rings, one at the bottom and one at the top): //BuildRing(meshBuilder, m_RadialSegmentCount, Vector3.zero, m_Radius, 0.0f, false); //BuildRing(meshBuilder, m_RadialSegmentCount, Vector3.up * m_Height, m_Radius, 1.0f, true); //multi-segment cylinder: float heightInc = m_Height / m_HeightSegmentCount; for (int i = 0; i <= m_HeightSegmentCount; i++) { //centre position of this ring: Vector3 centrePos = Vector3.up * heightInc * i; //V coordinate is based on height: float v = (float)i / m_HeightSegmentCount; BuildRing(meshBuilder, m_RadialSegmentCount, centrePos, m_Radius, v, i > 0); } ////caps: //BuildCap(meshBuilder, Vector3.zero, true); //BuildCap(meshBuilder, Vector3.up * m_Height, false); return meshBuilder.CreateMesh(); }
public static void BuildArcMesh(MeshBuilder meshBuilder, float innerRadius, float outerRadius, float startAngle, float endAngle, int steps) { float angleFull = endAngle - startAngle; float angleInc = angleFull / steps; float angle = startAngle; meshBuilder.Resize((steps+1)*2, steps*6); meshBuilder.ResetIndices (); for (int i = 0; i <= steps; ++i) { float uv = i/(float)steps; meshBuilder.AddVertex(GetArcPoint(innerRadius, angle)); meshBuilder.AddVertex(GetArcPoint(outerRadius, angle)); meshBuilder.AddUv(new Vector2(uv, 0)); meshBuilder.AddUv(new Vector2(uv, 1)); if ( i > 0 ) { int vi = meshBuilder.VertexIndex; meshBuilder.AddTriangle(vi-3, vi-4, vi-2); meshBuilder.AddTriangle(vi-1, vi-3, vi-2); } angle += angleInc; } }
/// <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) this.Model = modelGroup; }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //height segments need to be half m_RadialSegmentCount for the sphere to be even horizontally and vertically: int heightSegmentCount = m_RadialSegmentCount / 2; //the angle increment per height segment: float angleInc = Mathf.PI / heightSegmentCount; for (int i = 0; i <= heightSegmentCount; i++) { Vector3 centrePos = Vector3.zero; //calculate a height offset and radius based on a vertical circle calculation: centrePos.y = -Mathf.Cos(angleInc * i) * m_Radius; float radius = Mathf.Sin(angleInc * i) * m_Radius; float v = (float)i / heightSegmentCount; //build the ring: BuildRingForSphere(meshBuilder, m_RadialSegmentCount, centrePos, radius, v, i > 0); } return meshBuilder.CreateMesh(); }
public Mesh BuildSimplifiedConvexMesh() { var builder = new MeshBuilder(); for (int i = 0; i < 64; i++) { int index = Random.Range(0, mesh.triangles.Length / 3) * 3; Vector3[] triangle = new Vector3[] { mesh.vertices[mesh.triangles[index + 0]], mesh.vertices[mesh.triangles[index + 1]], mesh.vertices[mesh.triangles[index + 2]] }; Vector3[] norms = new Vector3[] { Vector3.up, Vector3.up, Vector3.up }; Vector2[] uvs = new Vector2[] { mesh.uv[mesh.triangles[index + 0]], mesh.uv[mesh.triangles[index + 1]], mesh.uv[mesh.triangles[index + 2]] }; builder.AddTriangleToMesh(triangle, norms, uvs); } return builder.Build(); }
//BuildQuad with vectors public static Mesh BuildQuad(MeshBuilder meshBuilder, Vector3 offset, Vector3 widthDir, Vector3 lengthDir) { Vector3 normal = Vector3.Cross(lengthDir, widthDir).normalized; meshBuilder.Vertices.Add(offset); meshBuilder.UVs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDir); meshBuilder.UVs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDir + widthDir); meshBuilder.UVs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + widthDir); meshBuilder.UVs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(normal); int baseIndex = meshBuilder.Vertices.Count - 4; meshBuilder.AddTriangle(baseIndex, baseIndex + 1, baseIndex + 2); meshBuilder.AddTriangle(baseIndex, baseIndex + 2, baseIndex + 3); Mesh _CreatedMesh = meshBuilder.CreateMesh(); _CreatedMesh.RecalculateNormals(); return _CreatedMesh; }
void BuildQuad(MeshBuilder meshBuilder, Vector3 offset, Vector3 widthDir, Vector3 lengthDir, int sizeX, int sizeY) { Vector3 normal = Vector3.Cross (lengthDir, widthDir).normalized; float vx, vy; // Define vertices e triangulos for (int y = 0; y <= sizeY; y++) { for (int x = 0; x <= sizeX; x++) { vx = ((float) x / sizeX); vy = ((float) y / sizeY); meshBuilder.Vertices.Add (offset + vx * lengthDir + vy * widthDir); meshBuilder.UVs.Add (new Vector2(vx, vy)); meshBuilder.Normals.Add (normal); } } int baseIndex = meshBuilder.Vertices.Count - (sizeX+1) * (sizeY+1); for (int vi = baseIndex, y = 0; y < sizeY; y++, vi++) { for (int x = 0; x < sizeX; x++, vi++) { meshBuilder.AddTriangle (vi, vi+1, vi+sizeX+2); meshBuilder.AddTriangle (vi, vi+sizeX+2, vi+sizeX+1); } } }
void BuildQuad(MeshBuilder meshBuilder, Vector3 offset, Vector3 widthDirection, Vector3 lengthDirection) { Vector3 normal = Vector3.Cross(lengthDirection, widthDirection).normalized; //Set up the vertices and triangles: meshBuilder.Vertices.Add(offset); meshBuilder.Uvs.Add(new Vector2(0.0f, 0.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDirection); meshBuilder.Uvs.Add(new Vector2(0.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + lengthDirection + widthDirection); meshBuilder.Uvs.Add(new Vector2(1.0f, 1.0f)); meshBuilder.Normals.Add(normal); meshBuilder.Vertices.Add(offset + widthDirection); meshBuilder.Uvs.Add(new Vector2(1.0f, 0.0f)); meshBuilder.Normals.Add(normal); int startPoint = meshBuilder.Vertices.Count - 4; if(first){ meshBuilder.AddTriangle(startPoint, startPoint + 1, startPoint + 2); meshBuilder.AddTriangle(startPoint, startPoint + 2, startPoint + 3); //first = false; } }
public MapMesh(MapCompiled map) { texture = new Texture("Images/wall.png"); material = new ObjMaterial("Models/wall.mtl").Lookup("wall"); colorGroups = new List<WallColorGroup>(); var colorMap = new Dictionary<Color, MeshBuilder<VertexTNP3>>(); foreach (var wall in map.Walls) { MeshBuilder<VertexTNP3> builder; if (!colorMap.TryGetValue(wall.Color, out builder)) { builder = new MeshBuilder<VertexTNP3>(); colorMap.Add(wall.Color, builder); } for (int i = 0; i < wall.Verts1.Length-1; i++) makeQuads(wall, builder, i, i+1); if (wall.Shape == ShapeData.Closed) makeQuads(wall, builder, wall.Verts1.Length-1, 0); } foreach (var pair in colorMap) { WallColorGroup g; g.Color = pair.Key; g.Mesh = pair.Value.ToMesh().Compile(); colorGroups.Add(g); } }
//public virtual Mesh BuildMesh() { // return new Mesh(); //} public Mesh BuildMesh(GizmoMeshShape shape, GizmoType type) { // SIMPLE CUBE! MeshBuilder meshBuilder = new MeshBuilder(); if(shape == GizmoMeshShape.Cube) { meshBuilder = EditorGizmoMeshShapes.GetCubeMesh(meshBuilder); //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT //BuildQuad(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM if(type != GizmoType.none) { collider = this.gameObject.AddComponent<BoxCollider>(); collider.isTrigger = true; } if (gizmoMaterial == null) { gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo")); //gizmoMaterial.renderQueue = 4000; } GetComponent<MeshRenderer>().material = gizmoMaterial; } else if(shape == GizmoMeshShape.Arrow) { EditorGizmoMeshShapes.GetArrowMesh(meshBuilder); if (type != GizmoType.none) { MeshCollider meshCollider = this.gameObject.AddComponent<MeshCollider>(); meshCollider.sharedMesh = meshBuilder.CreateMesh(); collider = meshCollider; //collider.isTrigger = true; } if (gizmoMaterial == null) { gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo")); //gizmoMaterial.renderQueue = 4000; } GetComponent<MeshRenderer>().material = gizmoMaterial; } else if (shape == GizmoMeshShape.OmniArrow) { EditorGizmoMeshShapes.GetOmniArrowMesh(meshBuilder); if (type != GizmoType.none) { MeshCollider meshCollider = this.gameObject.AddComponent<MeshCollider>(); meshCollider.sharedMesh = meshBuilder.CreateMesh(); collider = meshCollider; } if (gizmoMaterial == null) { gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo")); //gizmoMaterial.renderQueue = 4000; } GetComponent<MeshRenderer>().material = gizmoMaterial; } else { Debug.Log("No Gizmo Shape!!!"); } return meshBuilder.CreateMesh(); }
public void Generate(int chunkX, int chunkY, Map parent) { MeshFilter filter = this.gameObject.GetComponent<MeshFilter> (); if (filter == null) { filter = this.gameObject.AddComponent<MeshFilter> (); } MeshRenderer rend = this.gameObject.GetComponent<MeshRenderer> (); if (rend == null) { rend = this.gameObject.AddComponent<MeshRenderer> (); } rend.material = parent.mapMaterial; MeshBuilder meshBuilder = new MeshBuilder(); int startX = chunkX * 32; int startY = chunkY * 32; for (int i = startX; i < startX + 32; i++) { float xPos = TILE_SIZE * (i - startX); for (int j = startY; j < startY + 32; j++) { float yPos = TILE_SIZE * (j - startY); BuildTile(meshBuilder, new Vector3(xPos, 0, yPos), parent.getTile(i, j)); } } this.GetComponent<MeshFilter> ().sharedMesh = meshBuilder.CreateMesh (); this.transform.position = new Vector3(chunkX * Map.ChunkSize * TILE_SIZE, 0, chunkY * Map.ChunkSize * TILE_SIZE); }
void GenerateMesh() { float start_time = Time.time; NoiseGenerator gen = new NoiseGenerator(); noise = gen.generateNoise(width,width,100); MeshBuilder builder = new MeshBuilder(); Vector3 offset = new Vector3(0, 0, 0); for(int x = 0;x< width;x++){ for(int z=0;z< width;z++){ offset.z+= spacing; offset.y = noise[x * width + z] * Random.Range(-3,3); bool tri = x > 0 && z > 0; BuildQuadForGrid(builder,offset,new Vector2((1f/width)*x,(1f/width)*z),tri,width); } offset.x+= spacing; offset.z = 0; } if (terrainMesh != null) { Mesh mesh = builder.CreateMesh(); mesh.RecalculateNormals(); terrainMesh.sharedMesh = mesh; } float diff = Time.time - start_time; Debug.Log("ProceduralTerrain was generated in " + diff + " seconds."); }
public void BeginBuild(bool reverse = true) { meshBuilder = GetComponent<MeshBuilder>(); filter = GetComponent<MeshFilter>(); for (int i = 0; i <= xVal; i++)//xVal { float z = m_Length * i; float v = (1.0f / xVal) * i;//xVal for (int j = 0; j <= zVal; j++)//zVal { float x = m_Width * j; float u = (1.0f / zVal) * j;//zval Vector3 offset = new Vector3(x, 0, z); Vector2 uv = new Vector2(u, v); bool buildTriangles = i > 0 && j > 0; BuildQuadForGrid(meshBuilder, offset, uv, buildTriangles, zVal + 1);//zval } } if (filter != null) { filter.sharedMesh = meshBuilder.CreateMesh(reverse); //Debug.Log(filter.sharedMesh.vertexCount + " Vertices."); } }
public static void BuildRectangleMesh(MeshBuilder meshBuilder, float width, float height, float wStart, float hStart, float amount) { float fullW; float fullH; if ( width >= height ) { fullH = height*amount; fullW = width-(height-fullH); } else { fullW = width*amount; fullH = height-(width-fullW); } meshBuilder.Resize(4, 6); meshBuilder.ResetIndices(); meshBuilder.AddVertex(new Vector3(fullW, fullH, 0)); meshBuilder.AddVertex(new Vector3(fullW, fullH*hStart, 0)); meshBuilder.AddVertex(new Vector3(fullW*wStart, fullH*hStart, 0)); meshBuilder.AddVertex(new Vector3(fullW*wStart, fullH, 0)); meshBuilder.AddTriangle(0, 1, 2); meshBuilder.AddTriangle(0, 2, 3); meshBuilder.AddRemainingUvs(Vector2.zero); }
// Use this for initialization public override MeshBuilder AddToMeshBuilder(MeshBuilder meshBuilder = null) { if (meshBuilder == null) { meshBuilder = new MeshBuilder(); } float heightPerVertice = tunnelHeight / (heightVerticesNumber-1); circleOrigin = tunnelOrigin; circleOrigin.y += tunnelHeight / 2f; for(int h = 0; h < heightVerticesNumber; h++) { if (h == heightVerticesNumber -1) { addVertices = false; } meshBuilder = base.AddToMeshBuilder(meshBuilder); circleOrigin.y -= heightPerVertice; } return meshBuilder; }
private static void Shear(MeshBuilder builder, OpenBveApi.Math.Vector3 direction, OpenBveApi.Math.Vector3 shift, double ratio) { for (int i = 0; i < builder.Vertices.Length; i++) { double factor = ratio * OpenBveApi.Math.Vector3.Dot(builder.Vertices[i].SpatialCoordinates, direction); builder.Vertices[i].SpatialCoordinates += shift * factor; if (!builder.Vertices[i].Normal.IsNullVector()) { factor = ratio * OpenBveApi.Math.Vector3.Dot(builder.Vertices[i].Normal, shift); builder.Vertices[i].Normal -= direction * factor; if (!builder.Vertices[i].Normal.IsNullVector()) { builder.Vertices[i].Normal.Normalize(); } } } for (int i = 0; i < builder.FaceCount; i++) { for (int j = 0; j < builder.Faces[i].Vertices.Length; j++) { if (!builder.Faces[i].Vertices[j].Normal.IsNullVector()) { double factor = ratio * OpenBveApi.Math.Vector3.Dot(builder.Faces[i].Vertices[j].Normal, shift); builder.Faces[i].Vertices[j].Normal -= direction * factor; if (!builder.Faces[i].Vertices[j].Normal.IsNullVector()) { builder.Faces[i].Vertices[j].Normal.Normalize(); } } } } }
//Build the mesh: public override Mesh BuildMesh() { //Create a new mesh builder: MeshBuilder meshBuilder = new MeshBuilder(); //calculate directional vectors for all 3 dimensions of the cube: Vector3 upDir = Vector3.up * m_Height; Vector3 rightDir = Vector3.right * m_Width; Vector3 forwardDir = Vector3.forward * m_Length; //calculate the positions of two corners opposite each other on the cube: //positions that will place the pivot at the corner of the cube: Vector3 nearCorner = Vector3.zero; Vector3 farCorner = upDir + rightDir + forwardDir; ////positions that will place the pivot at the centre of the cube: //Vector3 farCorner = (upDir + rightDir + forwardDir) / 2; //Vector3 nearCorner = -farCorner; //build the 3 quads that originate from nearCorner: BuildQuad(meshBuilder, nearCorner, forwardDir, rightDir); BuildQuad(meshBuilder, nearCorner, rightDir, upDir); BuildQuad(meshBuilder, nearCorner, upDir, forwardDir); //build the 3 quads that originate from farCorner: BuildQuad(meshBuilder, farCorner, -rightDir, -forwardDir); BuildQuad(meshBuilder, farCorner, -upDir, -rightDir); BuildQuad(meshBuilder, farCorner, -forwardDir, -upDir); //initialise the Unity mesh and return it: return meshBuilder.CreateMesh(); }
public static MeshBuilder GetArrowMesh(MeshBuilder meshBuilder) { MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(0f, 0f, 1f), new Vector3(0.5f, 0.5f, -0.5f)); // TOP // clockwise triangle? MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, 0.5f, -0.5f), new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0f, 0f, 1f)); // LEFT MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.5f, -0.5f, -0.5f), new Vector3(0f, 0f, 1f)); // BOTTOM MeshBuilderPrimitiveShapes.BuildTriangle(meshBuilder, new Vector3(0.5f, 0.5f, -0.5f), new Vector3(0f, 0f, 1f), new Vector3(0.5f, -0.5f, -0.5f)); // RIGHT return meshBuilder; }
private void BuildMesh(MeshBuilder meshBuilder) { MeshNative.BuildArcMesh (meshBuilder, _innerRadius, _outerRadius, _startAngle, _endAngle, _meshStep); }
void BuildMesh(MeshBuilder meshBuilder) { MeshNative.BuildRectangleMesh (meshBuilder, _width, _height, _wStart, _hStart, _amount); }
public static MeshBuilder GetCubeMesh(MeshBuilder meshBuilder) { // SIMPLE CUBE! MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT MeshBuilderPrimitiveShapes.BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM return meshBuilder; }
// Use this for initialization void Start() { MeshBuilder meshBuilder = new MeshBuilder(); meshBuilder.Vertices.Add(new Vector3(-1f,-1f,-1f)); // 0 meshBuilder.Vertices.Add(new Vector3(-1f,-1f, 1f)); // 1 meshBuilder.Vertices.Add(new Vector3(-1f, 1f,-1f)); // 2 meshBuilder.Vertices.Add(new Vector3(-1f, 1f, 1f)); // 3 meshBuilder.Vertices.Add(new Vector3( 1f,-1f,-1f)); // 4 meshBuilder.Vertices.Add(new Vector3( 1f,-1f, 1f)); // 5 meshBuilder.Vertices.Add(new Vector3( 1f, 1f,-1f)); // 6 meshBuilder.Vertices.Add(new Vector3( 1f, 1f, 1f)); // 7 float phi = (1f + Mathf.Sqrt(5f))/2f; meshBuilder.Vertices.Add(new Vector3(0f, -1f/phi, -phi)); // 8 meshBuilder.Vertices.Add(new Vector3(0f, -1f/phi, phi)); // 9 meshBuilder.Vertices.Add(new Vector3(0f, 1f/phi, -phi)); // 10 meshBuilder.Vertices.Add(new Vector3(0f, 1f/phi, phi)); // 11 meshBuilder.Vertices.Add(new Vector3(-1f/phi, -phi, 0f)); // 12 meshBuilder.Vertices.Add(new Vector3(-1f/phi, phi, 0f)); // 13 meshBuilder.Vertices.Add(new Vector3( 1f/phi, -phi, 0f)); // 14 meshBuilder.Vertices.Add(new Vector3( 1f/phi, phi, 0f)); // 15 meshBuilder.Vertices.Add(new Vector3(-phi, 0f, -1f/phi)); // 16 meshBuilder.Vertices.Add(new Vector3( phi, 0f, -1f/phi)); // 17 meshBuilder.Vertices.Add(new Vector3(-phi, 0f, 1f/phi)); // 18 meshBuilder.Vertices.Add(new Vector3( phi, 0f, 1f/phi)); // 19 vertices = meshBuilder.Vertices; AddDodecahedronFace(meshBuilder, 7, 19, 17, 6, 15); AddDodecahedronFace(meshBuilder, 6, 17, 4, 8, 10); AddDodecahedronFace(meshBuilder, 15, 6, 10, 2, 13); AddDodecahedronFace(meshBuilder, 2, 10, 8, 0, 16); AddDodecahedronFace(meshBuilder, 13, 2, 16, 18, 3); AddDodecahedronFace(meshBuilder, 7, 15, 13, 3, 11); AddDodecahedronFace(meshBuilder, 4, 17, 19, 5, 14); AddDodecahedronFace(meshBuilder, 0, 8, 4, 14, 12); AddDodecahedronFace(meshBuilder, 18, 16, 0, 12, 1); AddDodecahedronFace(meshBuilder, 11, 3, 18, 1, 9); AddDodecahedronFace(meshBuilder, 19, 7, 11, 9, 5); AddDodecahedronFace(meshBuilder, 5, 9, 1, 12, 14); AddInternalCubeFace(meshBuilder, 2, 6, 4, 0); AddInternalCubeFace(meshBuilder, 6, 7, 5, 4); AddInternalCubeFace(meshBuilder, 7, 3, 1, 5); AddInternalCubeFace(meshBuilder, 3, 2, 0, 1); AddInternalCubeFace(meshBuilder, 3, 7, 6, 2); AddInternalCubeFace(meshBuilder, 5, 1, 0, 4); Mesh mesh = GetComponent<MeshFilter> ().mesh = meshBuilder.CreateMesh (); mesh.RecalculateBounds (); mesh.RecalculateNormals (); }
private static object buildTri() { var mb = new MeshBuilder(true, false); var p0 = new Point3D(0, 0, 0); var p1 = new Point3D(1, 0, 0); var p2 = new Point3D(1, 1, 0); mb.AddTriangle(p0, p1, p2); mb.Normals.ToList().ForEach(x => System.Diagnostics.Trace.WriteLine(x.ToString())); return mb.ToMesh(); }
/// <summary> /// Reads a triangular mesh. /// </summary> /// <param name="reader"> /// The reader. /// </param> /// <param name="chunkSize"> /// The chunk size. /// </param> private void ReadTriangularMesh(BinaryReader reader, int chunkSize) { MeshBuilder builder = new MeshBuilder(); int bytesRead = 6; Vector3Collection positions = null; IntCollection faces = null; Vector2Collection textureCoordinates = null; List <FaceSet> facesets = null; IntCollection triangleIndices = null; Vector3Collection normals = null; //Matrix matrix = Matrix.Identity; Vector3Collection tangents = null; Vector3Collection bitangents = null; List <Matrix> transforms = new List <Matrix>(); while (bytesRead < chunkSize) { ChunkID id = this.ReadChunkId(reader); int size = this.ReadChunkSize(reader); bytesRead += size; switch (id) { case ChunkID.TRI_VERTEXL: positions = this.ReadVertexList(reader); break; case ChunkID.TRI_FACEL1: faces = ReadFaceList(reader); size -= (faces.Count / 3 * 8) + 2; facesets = this.ReadFaceSets(reader, size - 6); break; case ChunkID.TRI_TEXCOORD: textureCoordinates = ReadTexCoords(reader); break; case ChunkID.TRI_LOCAL: transforms.Add(this.ReadTransformation(reader)); break; default: this.ReadData(reader, size - 6); break; } } if (faces == null) { //no faces defined?? return... return; } if (facesets == null || facesets.Count == 0) { triangleIndices = ConvertFaceIndices(faces, faces); CreateMesh(positions, textureCoordinates, triangleIndices, transforms, out normals, out tangents, out bitangents, new PhongMaterial() { Name = "Gray", AmbientColor = new Color4(0.1f, 0.1f, 0.1f, 1.0f), DiffuseColor = new Color4(0.254902f, 0.254902f, 0.254902f, 1.0f), SpecularColor = new Color4(0.0225f, 0.0225f, 0.0225f, 1.0f), EmissiveColor = new Color4(0.0f, 0.0f, 0.0f, 1.0f), SpecularShininess = 12.8f, }); //Add default get and setter } else { foreach (var fm in facesets) { triangleIndices = ConvertFaceIndices(fm.Faces, faces); MaterialCore mat = null; if (this.materials.ContainsKey(fm.Name)) { mat = this.materials[fm.Name]; } CreateMesh(positions, textureCoordinates, triangleIndices, transforms, out normals, out tangents, out bitangents, mat); } } }
/// <summary> /// This function contains all the "business logic" for constructing a SurfacePlot 3D. /// </summary> /// <returns>A Model3DGroup containing all the component models (mesh, surface definition, grid objects, etc).</returns> private Model3DGroup CreateModel() { var newModelGroup = new Model3DGroup(); double lineThickness = 0.01; double axesOffset = 0.05; // Get relevant constaints from the DataPoints object int numberOfRows = DataPoints.GetUpperBound(0) + 1; int numberOfColumns = DataPoints.GetUpperBound(1) + 1; // Determine the x, y, and z ranges of the DataPoints collection double minX = double.MaxValue; double maxX = double.MinValue; double minY = double.MaxValue; double maxY = double.MinValue; double minZ = double.MaxValue; double maxZ = double.MinValue; double minColorValue = double.MaxValue; double maxColorValue = double.MinValue; for (int i = 0; i < numberOfRows; i++) { for (int j = 0; j < numberOfColumns; j++) { double x = DataPoints[i, j].X; double y = DataPoints[i, j].Y; double z = DataPoints[i, j].Z; maxX = Math.Max(maxX, x); maxY = Math.Max(maxY, y); maxZ = Math.Max(maxZ, z); minX = Math.Min(minX, x); minY = Math.Min(minY, y); minZ = Math.Min(minZ, z); if (ColorValues != null) { maxColorValue = Math.Max(maxColorValue, ColorValues[i, j]); minColorValue = Math.Min(minColorValue, ColorValues[i, j]); } } } /* TEMP */ int numberOfXAxisTicks = 10; int numberOfYAxisTicks = 10; int numberOfZAxisTicks = 5; double XAxisInterval = (maxX - minX) / numberOfXAxisTicks; double YAxisInterval = (maxY - minY) / numberOfYAxisTicks; double ZAxisInterval = (maxZ - minZ) / numberOfZAxisTicks; /* /TEMP */ // Set color value to 0 at texture coordinate 0.5, with an even spread in either direction if (Math.Abs(minColorValue) < Math.Abs(maxColorValue)) { minColorValue = -maxColorValue; } else { maxColorValue = -minColorValue; } // Set the texture coordinates by either z-value or ColorValue var textureCoordinates = new Point[numberOfRows, numberOfColumns]; for (int i = 0; i < numberOfRows; i++) { for (int j = 0; j < numberOfColumns; j++) { double tc; if (ColorValues != null) { tc = (ColorValues[i, j] - minColorValue) / (maxColorValue - minColorValue); } else { tc = (DataPoints[i, j].Z - minZ) / (maxZ - minZ); } textureCoordinates[i, j] = new Point(tc, tc); } } // Build the surface model (i.e. the coloured surface model) MeshBuilder surfaceModelBuilder = new MeshBuilder(); surfaceModelBuilder.AddRectangularMesh(DataPoints, textureCoordinates); GeometryModel3D surfaceModel = new GeometryModel3D(surfaceModelBuilder.ToMesh(), MaterialHelper.CreateMaterial(SurfaceBrush, null, null, 1, 0)); surfaceModel.BackMaterial = surfaceModel.Material; // Instantiate MeshBuilder objects for the Grid and SurfaceMeshLines meshes MeshBuilder surfaceMeshLinesBuilder = new MeshBuilder(); MeshBuilder surfaceContourLinesBuilder = new MeshBuilder(); MeshBuilder gridBuilder = new MeshBuilder(); // Build the axes labels model (i.e. the object that holds the axes labels and ticks) ModelVisual3D axesLabelsModel = new ModelVisual3D(); // Loop through x intervals - for the surface meshlines, the grid, and X axes ticks for (double x = minX; x <= maxX + 0.0001; x += XAxisInterval) { // Add surface mesh lines which denote intervals along the x-axis var surfacePath = new List <Point3D>(); double i = (x - minX) / (maxX - minX) * (numberOfColumns - 1); for (int j = 0; j < numberOfColumns; j++) { surfacePath.Add(DoBilinearInterpolation(DataPoints, i, j)); } surfaceMeshLinesBuilder.AddTube(surfacePath, lineThickness, 9, false); // Axes labels BillboardTextVisual3D label = new BillboardTextVisual3D(); label.Text = string.Format("{0:F2}", x); label.Position = new Point3D(x, minY - axesOffset, minZ - axesOffset); axesLabelsModel.Children.Add(label); // Grid lines var gridPath = new List <Point3D>(); gridPath.Add(new Point3D(x, minY, minZ)); gridPath.Add(new Point3D(x, maxY, minZ)); gridPath.Add(new Point3D(x, maxY, maxZ)); gridBuilder.AddTube(gridPath, lineThickness, 9, false); } // Loop through y intervals - for the surface meshlines, the grid, and Y axes ticks for (double y = minY; y <= maxY + 0.0001; y += YAxisInterval) { // Add surface mesh lines which denote intervals along the y-axis var path = new List <Point3D>(); double j = (y - minY) / (maxY - minY) * (numberOfRows - 1); for (int i = 0; i < numberOfRows; i++) { path.Add(DoBilinearInterpolation(DataPoints, i, j)); } surfaceMeshLinesBuilder.AddTube(path, lineThickness, 9, false); // Axes labels BillboardTextVisual3D label = new BillboardTextVisual3D(); label.Text = string.Format("{0:F2}", y); label.Position = new Point3D(minX - axesOffset, y, minZ - axesOffset); axesLabelsModel.Children.Add(label); // Grid lines var gridPath = new List <Point3D>(); gridPath.Add(new Point3D(minX, y, minZ)); gridPath.Add(new Point3D(maxX, y, minZ)); gridPath.Add(new Point3D(maxX, y, maxZ)); gridBuilder.AddTube(gridPath, lineThickness, 9, false); } // Loop through z intervals - for the grid, and Z axes ticks for (double z = minZ; z <= maxZ + 0.0001; z += ZAxisInterval) { // Grid lines var path = new List <Point3D>(); path.Add(new Point3D(minX, maxY, z)); path.Add(new Point3D(maxX, maxY, z)); path.Add(new Point3D(maxX, minY, z)); gridBuilder.AddTube(path, lineThickness, 9, false); // Axes labels BillboardTextVisual3D label = new BillboardTextVisual3D(); label.Text = string.Format("{0:F2}", z); label.Position = new Point3D(minX - axesOffset, maxY + axesOffset, z); axesLabelsModel.Children.Add(label); } // Add axes labels BillboardTextVisual3D xLabel = new BillboardTextVisual3D(); xLabel.Text = "X Axis"; xLabel.Position = new Point3D((maxX - minX) / 2, minY - 3 * axesOffset, minZ - 5 * axesOffset); axesLabelsModel.Children.Add(xLabel); BillboardTextVisual3D yLabel = new BillboardTextVisual3D(); yLabel.Text = "Y Axis"; yLabel.Position = new Point3D(minX - 3 * axesOffset, (maxY - minY) / 2, minZ - 5 * axesOffset); axesLabelsModel.Children.Add(yLabel); BillboardTextVisual3D zLabel = new BillboardTextVisual3D(); zLabel.Text = "Z Axis"; zLabel.Position = new Point3D(minX - 5 * axesOffset, maxY + 5 * axesOffset, 0); // Note: trying to find the midpoint of minZ, maxZ doesn't work when minZ = -0.5 and maxZ = 0.5... axesLabelsModel.Children.Add(zLabel); // Create models from MeshBuilders GeometryModel3D surfaceMeshLinesModel = new GeometryModel3D(surfaceMeshLinesBuilder.ToMesh(), Materials.Black); GeometryModel3D gridModel = new GeometryModel3D(gridBuilder.ToMesh(), Materials.Black); // Update model group //this.Children.Add(axesLabelsModel); newModelGroup.Children.Add(surfaceModel); newModelGroup.Children.Add(surfaceMeshLinesModel); newModelGroup.Children.Add(gridModel); //ScaleTransform3D surfaceTransform = new ScaleTransform3D(20, 20, 20, 0, 0, 0); //newModelGroup.Transform = surfaceTransform; return(newModelGroup); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { var vm = value as OLMResultViewModel; if (vm == null) { return(null); } var graph = vm.GraphInFocus.Graph; var visuals = new GeometryModel3D[colors.Length]; var meshes = new MeshBuilder[colors.Length]; for (int i = 0; i < colors.Length; i++) { visuals[i] = new GeometryModel3D(); meshes[i] = new MeshBuilder(); } Model3DGroup modelGroup = new Model3DGroup(); var Emesh = new MeshBuilder(); foreach (var node in graph.Nodes) { if (!node.Neighbours.Any()) { continue; } Point3D center = new Point3D(node.Data.X, node.Data.Y, node.Data.Z); switch (vm.ViewType) { case ViewType.Default: if (node.Data.ReferenceLabel == 1 && vm.GraphInFocus.Prediction[node.GraphId] == 1) { meshes[0].AddSphere(center, 3, 8, 4); } else if (node.Data.ReferenceLabel == 1 && vm.GraphInFocus.Prediction[node.GraphId] == 0) { meshes[1].AddSphere(center, 3, 8, 4); } else if (node.Data.ReferenceLabel == 0 && vm.GraphInFocus.Prediction[node.GraphId] == 0) { meshes[2].AddSphere(center, 3, 8, 4); } else if (node.Data.ReferenceLabel == 0 && vm.GraphInFocus.Prediction[node.GraphId] == 1) { meshes[3].AddSphere(center, 3, 8, 4); } break; case ViewType.Reference: meshes[node.Data.ReferenceLabel % colors.Length].AddSphere(center, 3, 8, 4); break; case ViewType.Observation: meshes[node.Data.Observation % colors.Length].AddSphere(center, 3, 8, 4); break; case ViewType.Prediction: meshes[vm.GraphInFocus.Prediction[node.GraphId] % colors.Length].AddSphere(center, 3, 8, 4); break; default: meshes[node.Data.ReferenceLabel % colors.Length].AddSphere(center, 3, 8, 4); break; } } foreach (var edge in graph.Edges) { var foot = edge.Foot; var head = edge.Head; Point3D center1 = new Point3D(foot.Data.X, foot.Data.Y, foot.Data.Z); Point3D center2 = new Point3D(head.Data.X, head.Data.Y, head.Data.Z); Emesh.AddCylinder(center1, center2, 1, 4); } for (int i = 0; i < colors.Length; i++) { visuals[i] = new GeometryModel3D(meshes[i].ToMesh(), MaterialHelper.CreateMaterial(new SolidColorBrush(colors[i]))); modelGroup.Children.Add(visuals[i]); } modelGroup.Children.Add(new GeometryModel3D(Emesh.ToMesh(), MaterialHelper.CreateMaterial(new SolidColorBrush(Colors.Gray)))); return(modelGroup); }
/// <summary> /// Converts the mesh to a MeshGeometry3D. /// </summary> /// <param name="sharedVertices"> /// Allow shared vertices (smooth shading) if set to <c>true</c> . /// </param> /// <param name="shrinkFactor"> /// The shrink factor. /// </param> /// <param name="faceIndices"> /// The face indices. /// </param> /// <returns> /// A mesh geometry. /// </returns> public MeshGeometry3D ToMeshGeometry3D( bool sharedVertices = true, double shrinkFactor = 0.0, List <int> faceIndices = null) { bool shrink = Math.Abs(shrinkFactor) > double.Epsilon; if (!sharedVertices || shrink) { // not shared vertices - flat shading var tm = new MeshBuilder(false, this.TextureCoordinates != null); int faceIndex = 0; foreach (var face in this.Faces) { var vertices = new int[face.Length]; int j = 0; var centroid = this.FindCentroid(faceIndex); // var n = GetFaceNormal(faceIndex); // for (int i = 0; i < face.Length; i++) // tm.Normals.Add(n); foreach (int v in face) { vertices[j++] = tm.Positions.Count; var vertex = this.Vertices[v]; if (shrink) { vertex = vertex + (shrinkFactor * (centroid - vertex)); } tm.Positions.Add(vertex); if (tm.CreateTextureCoordinates) { tm.TextureCoordinates.Add(this.TextureCoordinates[v]); } } tm.AddTriangleFan(vertices); if (faceIndices != null) { int numberOfTriangles = vertices.Length - 2; for (int i = 0; i < numberOfTriangles; i++) { faceIndices.Add(faceIndex); } } faceIndex++; } return(tm.ToMesh()); } else { // shared vertices - smooth shading var tm = new MeshBuilder(false, this.TextureCoordinates != null); foreach (var v in this.Vertices) { tm.Positions.Add(v); } if (this.TextureCoordinates != null) { foreach (var uv in this.TextureCoordinates) { tm.TextureCoordinates.Add(uv); } } int faceIndex = 0; foreach (var face in this.Faces) { tm.AddTriangleFan(face); if (faceIndices != null) { int numberOfTriangles = face.Length - 2; for (int i = 0; i < numberOfTriangles; i++) { faceIndices.Add(faceIndex); } } faceIndex++; } return(tm.ToMesh()); } }
public abstract void Build(Vector3i localPos, Vector3i worldPos, Map map, MeshBuilder mesh, bool onlyLight);
public static BoneSkinnedMeshGeometry3D CreateSkeletonMesh(IList <Animations.Bone> bones, float scale = 1f) { var builder = new MeshBuilder(true, false); builder.AddPyramid(new Vector3(0, scale / 2, 0), Vector3.UnitZ, Vector3.UnitY, scale, 0, true); var singleBone = builder.ToMesh(); var boneIds = new List <BoneIds>(); var positions = new Vector3Collection(bones.Count * singleBone.Positions.Count); var tris = new IntCollection(bones.Count * singleBone.Indices.Count); var offset = 0; for (var i = 0; i < bones.Count; ++i) { if (bones[i].ParentIndex >= 0) { var currPos = positions.Count; tris.AddRange(singleBone.Indices.Select(x => x + offset)); var j = 0; for (; j < singleBone.Positions.Count - 6; j += 3) { positions.Add(Vector3.TransformCoordinate(singleBone.Positions[j], bones[bones[i].ParentIndex].BindPose)); positions.Add(Vector3.TransformCoordinate(singleBone.Positions[j + 1], bones[bones[i].ParentIndex].BindPose)); positions.Add(bones[i].BindPose.TranslationVector); boneIds.Add(new BoneIds() { Bone1 = bones[i].ParentIndex, Weights = new Vector4(1, 0, 0, 0) }); boneIds.Add(new BoneIds() { Bone1 = bones[i].ParentIndex, Weights = new Vector4(1, 0, 0, 0) }); boneIds.Add(new BoneIds() { Bone1 = i, Weights = new Vector4(1, 0, 0, 0) }); } for (; j < singleBone.Positions.Count; ++j) { positions.Add(Vector3.TransformCoordinate(singleBone.Positions[j], bones[bones[i].ParentIndex].BindPose)); boneIds.Add(new BoneIds() { Bone1 = bones[i].ParentIndex, Weights = new Vector4(1, 0, 0, 0) }); } offset += singleBone.Positions.Count; } } builder = new MeshBuilder(true, false); for (var i = 0; i < bones.Count; ++i) { var currPos = builder.Positions.Count; builder.AddSphere(Vector3.Zero, scale / 2, 12, 12); for (var j = currPos; j < builder.Positions.Count; ++j) { builder.Positions[j] = Vector3.TransformCoordinate(builder.Positions[j], bones[i].BindPose); boneIds.Add(new BoneIds() { Bone1 = i, Weights = new Vector4(1, 0, 0, 0) }); } } positions.AddRange(builder.Positions); tris.AddRange(builder.TriangleIndices.Select(x => x + offset)); var mesh = new BoneSkinnedMeshGeometry3D() { Positions = positions, Indices = tris, VertexBoneIds = boneIds }; mesh.Normals = mesh.CalculateNormals(); return(mesh); }
public MainViewModel() { EffectsManager = new DefaultEffectsManager(); RenderTechnique = EffectsManager[DefaultRenderTechniqueNames.Blinn]; this.Title = "Manipulator Demo"; this.SubTitle = null; // camera setup this.Camera = new OrthographicCamera { Position = new Point3D(0, 0, 5), LookDirection = new Vector3D(0, 0, -5), UpDirection = new Vector3D(0, 1, 0) }; // setup lighting this.AmbientLightColor = Colors.DimGray; this.DirectionalLightColor = Colors.White; this.DirectionalLightDirection = new Vector3D(-2, -5, -2); // floor plane grid this.Grid = LineBuilder.GenerateGrid(); this.GridColor = Colors.Black; this.GridTransform = new TranslateTransform3D(-5, -1, -5); // scene model3d var b1 = new MeshBuilder(); b1.AddSphere(new Vector3(0, 0, 0), 0.5); b1.AddBox(new Vector3(0, 0, 0), 1, 0.5, 1.5, BoxFaces.All); this.Model = b1.ToMeshGeometry3D(); var m1 = Load3ds("suzanne.3ds"); this.Model2 = m1[0].Geometry as MeshGeometry3D; //Manully set an offset for test for (int i = 0; i < Model2.Positions.Count; ++i) { Model2.Positions[i] = Model2.Positions[i] + new Vector3(2, 3, 4); } Model2.UpdateBounds(); // lines model3d var e1 = new LineBuilder(); e1.AddBox(new Vector3(0, 0, 0), 1, 0.5, 1.5); this.Lines = e1.ToLineGeometry3D(); // model trafos this.Model1Transform = new TranslateTransform3D(0, 0, 0); this.Model2Transform = new TranslateTransform3D(-3, 0, 0); this.Model3Transform = new TranslateTransform3D(+3, 0, 0); // model materials this.Material1 = PhongMaterials.Orange; this.Material2 = PhongMaterials.Orange; this.Material3 = PhongMaterials.Red; var dr = Colors.DarkRed; Console.WriteLine(dr); ResetTransformsCommand = new RelayCommand((o) => { this.Model1Transform = new TranslateTransform3D(0, 0, 0); this.Model2Transform = new TranslateTransform3D(-3, 0, 0); this.Model3Transform = new TranslateTransform3D(+3, 0, 0); }); }
private void SyncEditorGrids() { try { Gesture g = (Gesture)TheWorkspace.DataContext; // Enable/disable rows on SideViewGrid according to selection on FrontViewGrid GestureFrame sf = (GestureFrame)FramesListBox.SelectedItem; GestureFrameCell[] fcs = (GestureFrameCell[])FVGrid.ItemsSource; GestureFrameCell[] scs = (GestureFrameCell[])SVGrid.ItemsSource; // 'If' overcomes FVGrid_SelectionChanged firing before everything else and syncing SVGrid to a different Frame's FVGrid if (Object.ReferenceEquals(sf.FrontCells, fcs) && Object.ReferenceEquals(sf.SideCells, scs)) { IList frontViewGrid_selectedCells = (IList)FVGrid.SelectedItems; List <int> frontViewGrid_selectedRows = new List <int>(); foreach (GestureFrameCell c in frontViewGrid_selectedCells) { frontViewGrid_selectedRows.Add((int)(c.IndexInFrame / 20)); } for (int i = 0; i < 400; i++) { ListBoxItem sideViewGridItemContainer = (ListBoxItem)SVGrid.ItemContainerGenerator.ContainerFromIndex(i); if (frontViewGrid_selectedRows.Contains((int)(i / 20))) { sideViewGridItemContainer.IsEnabled = true; } else { sideViewGridItemContainer.IsEnabled = false; GestureFrame f = (GestureFrame)SVGrid.DataContext; f.SideCells[i].IsHotspot = false; } } } // Put hints for the current gesture's existing hotspots below both 2D grids FVHints.Children.Clear(); SVHints.Children.Clear(); for (int i = 0; i < 400; i++) { FVHints.Children.Add(new Border() { Background = Brushes.Transparent, BorderBrush = Brushes.Transparent }); SVHints.Children.Add(new Border() { Background = Brushes.Transparent, BorderBrush = Brushes.Transparent }); } foreach (GestureFrame f in g.Frames) { foreach (GestureFrameCell c in f.FrontCells.Where(c => c.IsHotspot)) { Border b = (Border)FVHints.Children[c.IndexInFrame]; b.Background = new SolidColorBrush() { Color = Colors.SlateBlue, Opacity = 0.2 }; } foreach (GestureFrameCell c in f.SideCells.Where(c => c.IsHotspot)) { Border b = (Border)SVHints.Children[c.IndexInFrame]; b.Background = new SolidColorBrush() { Color = Colors.SlateBlue, Opacity = 0.2 }; } } // Also sync 3D Viewport with grids // Init 3D stuff Model3DGroup modelGroup = new Model3DGroup(); foreach (GestureFrame f in g.Frames) { // Create material SolidColorBrush materialBrush = new SolidColorBrush() { Color = Colors.DarkSlateBlue, Opacity = 0.1 + ((double)(g.Frames.IndexOf(f) + 1) / (double)g.Frames.Count) * 0.8 }; DiffuseMaterial material = new DiffuseMaterial(materialBrush); foreach (GestureFrameCell fc in f.FrontCells.Where(fc => fc.IsHotspot == true)) { int fcIndex = Array.IndexOf(f.FrontCells, fc); foreach (GestureFrameCell sc in f.SideCells.Where( sc => sc.IsHotspot == true && (int)(Array.IndexOf(f.SideCells, sc) / 20) == (int)(fcIndex / 20))) { // Init mesh MeshBuilder meshBuilder = new MeshBuilder(false, false); // Make cube and add to mesh double y = (fc.LeftCM + fc.RightCM) / 2; double z = (fc.TopCM + fc.BottomCM) / 2; double x = (sc.LeftCM + sc.RightCM) / 2; Point3D cubeCenter = new Point3D(x, y, z); meshBuilder.AddBox(cubeCenter, 15, 15, 15); // Create and freeze mesh var mesh = meshBuilder.ToMesh(true); // Create model modelGroup.Children.Add(new GeometryModel3D(mesh, material)); } } } // Suggest other gestures too foreach (Gesture gg in GestureCollection) { foreach (GestureFrame f in gg.Frames) { // Create material SolidColorBrush materialBrush = new SolidColorBrush() { Color = Visualizer_GestureColors[GestureCollection.IndexOf(gg) % Visualizer_GestureColors.Length].Color, Opacity = ((double)(gg.Frames.IndexOf(f) + 1) / (double)gg.Frames.Count) * 0.09 }; DiffuseMaterial material = new DiffuseMaterial(materialBrush); foreach (GestureFrameCell fc in f.FrontCells.Where(fc => fc.IsHotspot == true)) { int fcIndex = Array.IndexOf(f.FrontCells, fc); foreach (GestureFrameCell sc in f.SideCells.Where( sc => sc.IsHotspot == true && (int)(Array.IndexOf(f.SideCells, sc) / 20) == (int)(fcIndex / 20))) { // Init mesh MeshBuilder meshBuilder = new MeshBuilder(false, false); // Make cube and add to mesh double y = (fc.LeftCM + fc.RightCM) / 2; double z = (fc.TopCM + fc.BottomCM) / 2; double x = (sc.LeftCM + sc.RightCM) / 2; Point3D cubeCenter = new Point3D(x, y, z); meshBuilder.AddBox(cubeCenter, 15, 15, 15); // Create and freeze mesh var mesh = meshBuilder.ToMesh(true); // Create model modelGroup.Children.Add(new GeometryModel3D(mesh, material)); } } } } HotspotCellsModelVisual3D_Editor.Content = modelGroup; } catch (NullReferenceException) { return; } }
public void A_B_C() { var mb = new MeshBuilder(); Assert.NotNull(mb); }
void Update() { if (this.voxelPickerObj == null) { this.voxelPickerObj = MeshBuilder.createWireframePicker(this.voxelWorld.gameObject, this.wireMaterial); } Vector3 lookingAt; Vector3 placeAt; byte blockId; if (this.voxelWorld.getPlayerBlockPick(this.transform, out lookingAt, out placeAt, out blockId)) { this.voxelPickerObj.SetActive(true); this.voxelPickerObj.transform.position = lookingAt + this.pickBlockOffset; this.breakingBlock.transform.position = lookingAt + this.pickBlockOffset; if (Input.GetMouseButtonDown(0)) { this.isBreaking = true; this.breakingBlock.SetActive(true); this.breakClickTime = Time.time; } else if (Input.GetMouseButtonUp(0)) { this.isBreaking = false; this.breakingBlock.SetActive(false); } if (Input.GetMouseButtonDown(1)) { Block block = this.voxelWorld.getBlocks()[this.selectedBlock]; if (block.isDestroyable) { this.voxelWorld.getWorld().setBlockId(placeAt, (byte)block.id); } } if (this.isBreaking) { Block block = this.voxelWorld.getBlockInstance(blockId); float timeElapsed = Time.time - this.breakClickTime; float breakTime = block.hardness * 0.5f; if (block.isDestroyable) { setBreakingTexture(timeElapsed / breakTime); if (timeElapsed >= breakTime) { this.voxelWorld.getWorld().setBlockId(lookingAt, 0); this.breakClickTime = Time.time; } } else { setBreakingTexture(0); } } } else { this.isBreaking = false; this.breakingBlock.SetActive(false); this.voxelPickerObj.SetActive(false); } if (Input.GetAxis("Mouse ScrollWheel") > 0) { this.selectedBlock--; } else if (Input.GetAxis("Mouse ScrollWheel") < 0) { this.selectedBlock++; } }
public MainPageViewModel() { EffectsManager = new DefaultEffectsManager(new Logger()); Camera = new PerspectiveCamera() { Position = new Vector3(40, 10, 100), LookDirection = new Vector3(0, -10, -100), UpDirection = UpDirection, FarPlaneDistance = 500, NearPlaneDistance = 0.1 }; Camera1 = new OrthographicCamera() { Position = new Vector3(60, 10, 100), LookDirection = new Vector3(0, -10, -100), UpDirection = upDirection, Width = 30, FarPlaneDistance = 2000, NearPlaneDistance = 20 }; var builder = new MeshBuilder(true, true, true); builder.AddBox(new SharpDX.Vector3(0, 0, 0), 2, 2, 2); builder.AddSphere(new Vector3(0, 2, 0), 1.5); Geometry = builder.ToMesh(); Geometry.UpdateOctree(); builder = new MeshBuilder(); builder.AddSphere(new Vector3(0, 2, 0), 2); Sphere = builder.ToMesh(); Sphere.UpdateOctree(); Material = new PhongMaterial() { AmbientColor = Color.Gray, DiffuseColor = new Color4(0.75f, 0.75f, 0.75f, 1.0f), SpecularColor = Color.White, SpecularShininess = 10f, ReflectiveColor = new Color4(0.2f, 0.2f, 0.2f, 0.5f), RenderEnvironmentMap = true }; Material.DiffuseMap = LoadTexture("TextureCheckerboard2.jpg"); Material.NormalMap = LoadTexture("TextureCheckerboard2_dot3.jpg"); Material1 = Material.CloneMaterial(); Material1.ReflectiveColor = Color.Silver; Material1.RenderDiffuseMap = false; Material1.RenderNormalMap = false; Material1.RenderEnvironmentMap = true; var lineBuilder = new LineBuilder(); lineBuilder.AddLine(Vector3.Zero, new Vector3(5, 0, 0)); lineBuilder.AddLine(Vector3.Zero, new Vector3(0, 5, 0)); lineBuilder.AddLine(Vector3.Zero, new Vector3(0, 0, 5)); LineGeometry = lineBuilder.ToLineGeometry3D(); LineGeometry.Colors = new HelixToolkit.UWP.Core.Color4Collection() { Color.Red, Color.Red, Color.Green, Color.Green, Color.Blue, Color.Blue }; builder = new MeshBuilder(); builder.AddSphere(new Vector3(), 3); var mesh = builder.ToMesh(); mesh.UpdateOctree(); PointGeometry = new PointGeometry3D() { Positions = mesh.Positions }; AxisLabelGeometry = new BillboardText3D(); AxisLabelGeometry.TextInfo.Add(new TextInfo("X", new Vector3(5.5f, 0, 0)) { Foreground = Color.Red }); AxisLabelGeometry.TextInfo.Add(new TextInfo("Y", new Vector3(0, 5.5f, 0)) { Foreground = Color.Green }); AxisLabelGeometry.TextInfo.Add(new TextInfo("Z", new Vector3(0, 0, 5.5f)) { Foreground = Color.Blue }); builder = new MeshBuilder(); builder.AddBox(new Vector3(0, -6, 0), 30, 0.5, 30); FloorModel = builder.ToMesh(); FloorMaterial = PhongMaterials.Obsidian; FloorMaterial.ReflectiveColor = Color.Silver; EnvironmentMap = LoadTexture("Cubemap_Grandcanyon.dds"); UpDirXCommand = new RelayCommand(() => { UpDirection = Vector3.UnitX; }, () => { return(UpDirection != Vector3.UnitX); }); UpDirYCommand = new RelayCommand(() => { UpDirection = Vector3.UnitY; }, () => { return(UpDirection != Vector3.UnitY); }); UpDirZCommand = new RelayCommand(() => { UpDirection = Vector3.UnitZ; }, () => { return(UpDirection != Vector3.UnitZ); }); timer = new DispatcherTimer(); timer.Tick += Timer_Tick; timer.Interval = new TimeSpan(0, 0, 0, 0, 16); timer.Start(); }
public PBRViewModel(IEffectsManager manager) { EffectsManager = manager; this.Camera = new PerspectiveCamera { Position = new Point3D(0, 60, 60), LookDirection = new Vector3D(0, -60, -60), UpDirection = new Vector3D(0, 1, 0) }; var builder = new MeshBuilder(); builder.AddSphere(Vector3.Zero, 2); SphereModel = builder.ToMesh(); var normalMap = LoadFileToMemory(new System.Uri("TextureNoise1_dot3.dds", System.UriKind.RelativeOrAbsolute).ToString()); for (int i = -Row; i < Row; ++i) { for (int j = -Col; j < Col; ++j) { var m = new PBRMaterial() { AlbedoColor = albedoColor.ToColor4(), RoughnessFactor = 1.0 / (2 * Row) * Math.Abs(i + Row), MetallicFactor = 1.0 / (2 * Col) * Math.Abs(j + Col), RenderEnvironmentMap = true, EnableAutoTangent = true, NormalMap = normalMap, RenderShadowMap = true }; materials.Add(m); Models.Add(new MeshGeometryModel3D() { CullMode = SharpDX.Direct3D11.CullMode.Back, Geometry = SphereModel, Material = m, IsThrowingShadow = true, Transform = new Media3D.TranslateTransform3D(new Vector3D(i * 6, 0, j * 6)) }); } } builder = new MeshBuilder(); builder.AddSphere(Vector3.Zero, 8, 12, 12); Model = builder.ToMesh(); Material = new PBRMaterial() { AlbedoColor = albedoColor.ToColor4(), RenderEnvironmentMap = true, AlbedoMap = LoadFileToMemory("Engraved_Metal_COLOR.jpg"), NormalMap = LoadFileToMemory("Engraved_Metal_NORM.jpg"), DisplacementMap = LoadFileToMemory("Engraved_Metal_DISP.png"), RMAMap = LoadFileToMemory("Engraved_Metal_RMC.png"), DisplacementMapScaleMask = new Vector4(0.1f, 0.1f, 0.1f, 0), EnableAutoTangent = true, EnableTessellation = true, MaxDistanceTessellationFactor = 2, MinDistanceTessellationFactor = 4 }; ModelTransform = new Media3D.MatrixTransform3D(Matrix.Translation(0, 30, 0).ToMatrix3D()); builder = new MeshBuilder(); builder.AddBox(Vector3.Zero, 100, 0.5, 100); var floorGeo = builder.ToMesh(); for (int i = 0; i < floorGeo.TextureCoordinates.Count; ++i) { floorGeo.TextureCoordinates[i] *= 5; } FloorModel = floorGeo; FloorMaterial = new PBRMaterial() { AlbedoMap = LoadFileToMemory("Wood_Planks_COLOR.jpg"), NormalMap = LoadFileToMemory("Wood_Planks_NORM.jpg"), DisplacementMap = LoadFileToMemory("Wood_Planks_DISP.png"), RMAMap = LoadFileToMemory("Wood_Planks_RMA.png"), DisplacementMapScaleMask = new Vector4(1f, 1f, 1f, 0), RoughnessFactor = 0.8, MetallicFactor = 0.2, RenderShadowMap = true, EnableAutoTangent = true, }; FloorModelTransform = new Media3D.MatrixTransform3D(Matrix.Translation(0, -5, 0).ToMatrix3D()); }
public MainViewModel() { this.Title = "Environment Mapping Demo"; this.SubTitle = "HelixToolkitDX"; // camera setup this.Camera = new PerspectiveCamera { Position = new Point3D(10, 0, 0), LookDirection = new Vector3D(-10, 0, 0), UpDirection = new Vector3D(0, 1, 0) }; //this.Camera = new OrthographicCamera { Position = new Point3D(3, 3, 5), LookDirection = new Vector3D(-3, -3, -5), UpDirection = new Vector3D(0, 1, 0) }; // lighting setup this.AmbientLightColor = new Color4(0.5f, 0.5f, 0.5f, 1.0f); this.DirectionalLightColor = Color.White; this.DirectionalLightDirection = new Vector3(-2, -1, 1); // scene model3d LoadModel("teapot_quads_tex.obj", MeshFaces.Default); this.ModelTransform = new Media3D.TranslateTransform3D(); this.ModelMaterial = PhongMaterials.PolishedSilver; this.ModelMaterial.ReflectiveColor = Color.Silver; this.ModelMaterial.RenderEnvironmentMap = true; var b1 = new MeshBuilder(true); b1.AddSphere(new Vector3(0, 0, 0), 1.0, 64, 64); b1.AddBox(new Vector3(0, 0, 0), 1, 0.5, 3, BoxFaces.All); this.Model1 = b1.ToMeshGeometry3D(); EffectsManager = new DefaultEffectsManager(); RenderTechnique = EffectsManager[DefaultRenderTechniqueNames.Blinn]; SkyboxTexture = LoadFileToMemory("Cubemap_Grandcanyon.dds"); int t = 5; for (int i = 0; i < 10; ++i) { Instances1.Add(Matrix.Translation(new Vector3(t, t, (i - 5) * t))); } for (int i = 0; i < 10; ++i) { Instances2.Add(Matrix.Translation(new Vector3(t, (i - 5) * t, t))); } for (int i = 0; i < 10; ++i) { Instances3.Add(Matrix.Translation(new Vector3(-(i - 5) * t, t, (i - 5) * t))); } //int t = 5; //Instances.Add(Matrix.Translation(new Vector3(t, t, t))); //Instances.Add(Matrix.Translation(new Vector3(-t, t, t))); //Instances.Add(Matrix.Translation(new Vector3(-t, -t, t))); //Instances.Add(Matrix.Translation(new Vector3(-t, -t, -t))); //Instances.Add(Matrix.Translation(new Vector3(t, -t, t))); //Instances.Add(Matrix.Translation(new Vector3(t, -t, -t))); //Instances.Add(Matrix.Translation(new Vector3(-t, t, -t))); //Instances.Add(Matrix.Translation(new Vector3(t, t, -t))); this.ModelMaterial1 = PhongMaterials.Red; this.ModelMaterial1.AmbientColor = Color.Red; this.ModelMaterial1.RenderEnvironmentMap = true; this.ModelMaterial2 = PhongMaterials.Green; this.ModelMaterial2.AmbientColor = Color.Green; this.ModelMaterial2.RenderEnvironmentMap = true; this.ModelMaterial3 = PhongMaterials.Blue; this.ModelMaterial3.AmbientColor = Color.Blue; this.ModelMaterial3.RenderEnvironmentMap = true; }
/// <summary> /// Adds a mesh. /// </summary> public void AddMesh() { var meshBuilder = new MeshBuilder(true, true); this.meshBuilders.Add(meshBuilder); }
private void FileOpenRaw() { CurrentModelPath = FileDialogService.OpenFileDialog("models", null, OpenFileFilter, ".3ds"); #if !DEBUG try { #endif ///* Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); CurrentModel = ModelImporter.Load(CurrentModelPath); Model3DGroup group = new Model3DGroup(); if (CurrentModel != null) { var mb = new MeshBuilder(false, false); Rect3D r = CurrentModel.Bounds; Model3DGroup g = (Model3DGroup)CurrentModel; foreach (GeometryModel3D gm in g.Children) { MeshGeometry3D mesh = (MeshGeometry3D)gm.Geometry; Point3DCollection ind = mesh.Positions; for (int i = 0; i < ind.Count; i++) { var p0 = ind[i]; p0 = new Point3D(p0.X + (-(r.X + (r.SizeX / 2))), p0.Y + (-(r.Y + (r.SizeY / 2))), p0.Z + (-(r.Z + (r.SizeZ / 2)))); mb.Positions.Add(p0); } for (int i = 0; i < mesh.TriangleIndices.Count; i++) { mb.TriangleIndices.Add(mesh.TriangleIndices[i]); } } var geom = new GeometryModel3D(mb.ToMesh(), MaterialHelper.CreateMaterial(Colors.BlueViolet)); geom.BackMaterial = MaterialHelper.CreateMaterial(Colors.Chocolate); group.Children.Add(geom); /* * //ADD COUNTOUR * var segments = MeshGeometryHelper.GetContourSegments(geom.Geometry as MeshGeometry3D, new Point3D(0,0,0), new Vector3D(0,0,1)); * foreach (var contour in MeshGeometryHelper.CombineSegments(segments, 1e-6)) * { * if (contour.Count == 0) * continue; * HelixView.Viewport.Children.Add(new TubeVisual3D { Diameter = 0.03, Path = new Point3DCollection(contour), Fill = Brushes.Green }); * } * //*/ /* * //FIND EDGES * var edges = MeshGeometryHelper.FindEdges(geom.Geometry as MeshGeometry3D); * for (int i = 0; i < edges.Count; i+=2) * { * Point3DCollection points = new Point3DCollection(); * MeshGeometry3D ms = geom.Geometry as MeshGeometry3D; * Point3D p0 = ms.Positions[edges[i]]; * Point3D p1 = ms.Positions[edges[i+1]]; * points.Add(p0); * points.Add(p1); * HelixView.Viewport.Children.Add(new TubeVisual3D { Diameter = 0.03, Path = new Point3DCollection(points), Fill = Brushes.Black}); * } * //*/ CurrentModel = group; //Transform3DGroup tgroup = new Transform3DGroup(); //tgroup.Children.Add(new TranslateTransform3D(-(r.X + (r.SizeX / 2)), -(r.Y + (r.SizeY / 2)), -(r.Z + (r.SizeZ / 2)))); //tgroup.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0,1,0), 45))); //CurrentModel.Transform = tgroup; //CurrentModel.Freeze(); if (RawVisual == null) { RawVisual = new RawVisual3D(RootVisual); } //RawVisual.Content = CurrentModel; RawVisual.Content = CurrentModel; RawVisual.ShowBoundingBox = true; RawVisual.showHideBoundingBox(); RootVisual.Children.Add(RawVisual); smileMode = "RAW"; //if(!HelixView.Viewport.Children.Contains(RootVisual)) HelixView.Viewport.Children.Add(RootVisual); //ModelVisual3D v = new ModelVisual3D(); //v.Content = CurrentModel; //RootVisual.Children.Add(v); //*/ /* * List<Point3D> pts = new List<Point3D>(); * pts.Add(new Point3D(30.4960694492679, 5.52461072334257, 9.44661196022868)); * pts.Add(new Point3D(28.0998337010248, 6.66945199865937, 14.4798151385421)); * pts.Add(new Point3D(28.2102015086476, -0.126599907551222, 19.0159875772706)); * pts.Add(new Point3D(29.7392389441408, -4.1789883548182, 14.8532955485325)); * pts.Add(new Point3D(28.4974026994517, -2.89939719282193, 8.04165108434179)); * pts.Add(new Point3D(24.1236797131164, 1.10693238332609, 6.46814289839299)); * * for (var i = 0; i < pts.Count; i++) * { * BoxVisual3D b = new BoxVisual3D(); * b.Center = pts[i]; * b.Length = 2; * b.Height = 2; * b.Width = 2; * HelixView.Viewport.Children.Add(b); * } */ ApplicationTitle = String.Format(TitleFormatString, CurrentModelPath); HelixView.ZoomExtents(0); showStatus(stopWatch, "Loaded"); } #if !DEBUG } catch (Exception e) { MessageBox.Show(e.Message); } #endif }
/// <summary> /// Load sensors in model /// </summary> /// <param name="sensors">List of sensors</param> /// <param name="analysisName">Analysis name</param> public void LoadSensorsInModel(IEnumerable <Sensor> sensors, string analysisName) { // this.ViewPort3d.Children.Remove(this.device3D); this.sensorGroupModel.Children.Clear(); this.sensorGroupModel.Children.Add(this.stlModel); this.sensorModelArray[this.dataCounter] = new List <GeometryModel3D>(); foreach (Sensor sensor in sensors) { MeshBuilder meshBuilder = new MeshBuilder(); Color color = new Color() { A = 255, R = 255, G = 255, B = 0 }; if (sensor.Values.Count != 0 && !string.IsNullOrEmpty(analysisName)) { // Get data from analysis IEnumerable <SensorValue> svc = from values in sensor.Values where values.AnalysisName == analysisName select values; if (svc.Count() > 0) { // Group by parameters IEnumerable <IGrouping <string, SensorValue> > asd = svc.GroupBy(a => a.Parameter); foreach (IGrouping <string, SensorValue> gp in asd) { // If parameter is direction then add arrow with the value if (gp.Key == this.parameterString) { double cte = gp.Last().Value *Math.PI / 180; Point3D newPoint = new Point3D(sensor.X + (4 * sensor.Size * Math.Cos(cte)), sensor.Y + (4 * sensor.Size * Math.Sin(cte)), sensor.Z); meshBuilder.AddArrow(new Point3D(sensor.X, sensor.Y, sensor.Z), newPoint, this.arrowDiameterSize, this.arrowHeadSize); } else { // With the respective color color = Interpolation.GetHeatMapColor(gp.Last().Value, -1, +1); } } } else { color = new Color() { A = 255, R = 255, G = 255, B = 0 }; } } meshBuilder.AddBox(new Point3D(sensor.X, sensor.Y, sensor.Z), sensor.Size, sensor.Size, this.sizeZ); GeometryModel3D sensorModel = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(color)); this.sensorModelArray[this.dataCounter].Add(sensorModel); this.sensorGroupModel.Children.Add(sensorModel); } this.GroupModel = this.sensorGroupModel; this.device3D.Content = this.groupModel; if (!this.ViewPort3d.Children.Contains(this.device3D)) { this.ViewPort3d.Children.Add(this.device3D); } }
/// <summary> /// Load sensors in model /// </summary> /// <param name="sensors">List of sensors</param> public void LoadSensorsValuesInModel(IEnumerable <Sensor> sensors) { this.sensorGroupModel.Children.Clear(); this.sensorGroupModel.Children.Add(this.stlModel); this.sensorModelArray[this.dataCounter] = new List <GeometryModel3D>(); foreach (Sensor sensor in sensors) { MeshBuilder meshBuilder = new MeshBuilder(); IEnumerable <IGrouping <string, SensorValue> > asd = sensor.Values.GroupBy(a => a.Parameter); double value = 0; foreach (IGrouping <string, SensorValue> gp in asd) { if (gp.Key == this.parameterString) { double cte = gp.Last().Value *Math.PI / 180; Point3D newPoint = new Point3D(sensor.X + (4 * sensor.Size * Math.Cos(cte)), sensor.Y + (4 * sensor.Size * Math.Sin(cte)), sensor.Z); meshBuilder.AddArrow(new Point3D(sensor.X, sensor.Y, sensor.Z), newPoint, this.arrowDiameterSize, this.arrowHeadSize); } else { value = gp.Last().Value; meshBuilder.AddBox(new Point3D(sensor.X, sensor.Y, sensor.Z), sensor.Size, sensor.Size, this.sizeZ); } } Color color; // If sensor does not receive any value, receives yellow as collor if (sensor.Values.Count != 0) { color = Interpolation.GetHeatMapColor(value, -1, +1); } else { color = new Color() { A = 255, R = 255, G = 255, B = 0 }; } GeometryModel3D sensorModel = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(color)); this.sensorModelArray[this.dataCounter].Add(sensorModel); this.sensorGroupModel.Children.Add(sensorModel); } if (this.modelMesh != null) { this.vertices[this.dataCounter++] = this.interpolation.Interpolate2(this.modelMesh, this.SensorsNotParameter(sensors)); this.MaxSlider = this.dataCounter - 1; this.Slider = this.MaxSlider; } this.GroupModel = this.sensorGroupModel; this.device3D.Content = this.groupModel; if (!this.ViewPort3d.Children.Contains(this.device3D)) { this.ViewPort3d.Children.Add(this.device3D); } }
public static MeshBuilder CreateTorusFlat(float flipAngle, float phaseAngle, float radius, float width, int segments, int sectors, bool collisionMesh) { var meshBuilder = new MeshBuilder(collisionMesh); var vertices = meshBuilder.vertices; var indices = meshBuilder.indices; var normals = meshBuilder.normals; var uvs = meshBuilder.uvs; var colors = meshBuilder.colors; var deltaAngle = Mathf.PI * 2 / sectors; for (int segment = 0; segment <= segments; segment++) { var center = new Vector3(radius, 0, 0); var yRotation = Quaternion.Euler(0, 360f * segment / segments, 0); var zRotation = Quaternion.Euler(0, 0, phaseAngle + flipAngle * segment / segments); for (int sector = 0; sector < sectors; sector++) { var angle = Mathf.PI * 2 / sectors * sector; var normal1 = new Vector3(Mathf.Cos(angle), Mathf.Sin(angle), 0); var normal2 = new Vector3(Mathf.Cos(angle + deltaAngle), Mathf.Sin(angle + deltaAngle), 0); var position1 = center + zRotation * (width * normal1); var position2 = center + zRotation * (width * normal2); vertices.Add(yRotation * position1); vertices.Add(yRotation * position2); if (collisionMesh == false) { var normal = yRotation * zRotation * new Vector3(Mathf.Cos(angle + deltaAngle / 2), Mathf.Sin(angle + deltaAngle / 2), 0); var uv1 = new Vector2(1 - segment / (float)segments, sector / (float)sectors); var uv2 = new Vector2(1 - segment / (float)segments, (sector + 1) / (float)sectors); normals.Add(normal); normals.Add(normal); uvs.Add(uv1); uvs.Add(uv2); colors.Add(color); colors.Add(color); } } } for (int segment = 0; segment < segments; segment++) { for (int sector = 0; sector < sectors; sector++) { int firstVertexIndex1 = segment * sectors * 2 + sector * 2; int firstVertexIndex2 = (segment + 1) * sectors * 2 + sector * 2; indices.Add(firstVertexIndex1 + 1); indices.Add(firstVertexIndex1); indices.Add(firstVertexIndex2); indices.Add(firstVertexIndex2); indices.Add(firstVertexIndex2 + 1); indices.Add(firstVertexIndex1 + 1); } } return(meshBuilder); }
/// <summary> /// Load sensors in model /// </summary> /// <param name="sensors">List of sensors</param> /// <param name="analysisName">Analysis name</param> public void LoadSensorsInModel2(IEnumerable <Sensor> sensors, string analysisName) { // this.ViewPort3d.Children.Remove(this.device3D); this.sensorGroupModel.Children.Clear(); this.sensorGroupModel.Children.Add(this.stlModel); this.sensorModelArray[this.dataCounter] = new List <GeometryModel3D>(); int pos = 0; foreach (Sensor sensor in sensors) { Color color = new Color() { A = 255, R = 255, G = 255, B = 0 }; MeshBuilder meshBuilder; if (sensor.Values.Count != 0) { // Get data from analysis IEnumerable <SensorValue> svc = from values in sensor.Values where values.AnalysisName == analysisName select values; if (svc.Count() > 0) { // Group by parameters List <IGrouping <string, SensorValue> > grouped = svc.GroupBy(a => a.Parameter).ToList(); int[] indexs = grouped[0].Key == this.parameterString ? new int[] { 0, 1 } : new int[] { 1, 0 }; for (int i = 0; i < grouped[indexs[1]].Count(); i++) { if (this.sensorModelArray[i] == null) { this.sensorModelArray[i] = new List <GeometryModel3D>(); } meshBuilder = new MeshBuilder(); color = Interpolation.GetHeatMapColor(grouped[indexs[1]].ElementAt(i).Value, -1, +1); meshBuilder.AddBox(new Point3D(sensor.X, sensor.Y, sensor.Z), sensor.Size, sensor.Size, this.sizeZ); if (grouped.Count > 1) { double cte = grouped[indexs[0]].ElementAt(i).Value *Math.PI / 180; Point3D newPoint = new Point3D(sensor.X + (4 * sensor.Size * Math.Cos(cte)), sensor.Y + (4 * sensor.Size * Math.Sin(cte)), sensor.Z); meshBuilder.AddArrow(new Point3D(sensor.X, sensor.Y, sensor.Z), newPoint, this.arrowDiameterSize, this.arrowHeadSize); } GeometryModel3D sensorModel2 = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(color)); this.sensorModelArray[i].Add(sensorModel2); } } else { meshBuilder = new MeshBuilder(); color = new Color() { A = 255, R = 255, G = 255, B = 0 }; meshBuilder.AddBox(new Point3D(sensor.X, sensor.Y, sensor.Z), sensor.Size, sensor.Size, this.sizeZ); GeometryModel3D sensorModel2 = new GeometryModel3D(meshBuilder.ToMesh(), MaterialHelper.CreateMaterial(color)); this.sensorModelArray[pos].Add(sensorModel2); } } } // TODO // foreach (var model3d in this.sensorModelArray[this.sensorModelArray.Length - 1]) foreach (var model3d in this.sensorModelArray[0]) { this.sensorGroupModel.Children.Add(model3d); } this.GroupModel = this.sensorGroupModel; this.device3D.Content = this.groupModel; if (!this.ViewPort3d.Children.Contains(this.device3D)) { this.ViewPort3d.Children.Add(this.device3D); } }