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);
}
}
