A raw, un-optimize, fully mutable, representation of a static mesh More...

Inheritance diagram for pluginbase.Helpers.Mesh.Mesh:

Public Member Functions
IEnumerable< Triangle >	TrianglesInGroup (TriangleGroup group)

IEnumerable< Triangle >	TrianglesInGroup (string groupName)

	Mesh (bool autoNormals)

	Mesh ()

Triangle	AddTriangle ()

Triangle	AddTriangle (Vertex[] v, Material mat=null)

Triangle	AddTriangle (Vertex a, Vertex b, Vertex c, Material mat=null, TriangleGroup group=null)

Triangle	AddTriangle (Triangle tri)

Triangle []	AddQuad (Vertex a, Vertex b, Vertex c, Vertex d, Material material=null, TriangleGroup group=null)

void	ReverseVertexOrder ()
	Flips vertex order on all triangles eg. from (1,2,3) to (3,2,1) Useful when normals are generating backwards More...

void	ComputeFlatNormals ()
	Computes the flat normals. Vert fast, but assumes each triangle has its own unique set of vertices More...

void	ComputeSmoothNormalsByRef ()
	Computes the smooth normals by reference. Mid-range speed O(v * t). Only works if vertices are propertly created with references to each other in an indexed way More...

void	ComputeSmoothNormalsByProximity ()
	Computes the smooth normals by proximity of the coordinate. Slowest, but most accurate, method More...

void	Merge (Mesh mesh)
	Merge multiple meshes More...

AxisAlignedBox	ComputeBoundingBox ()

Mesh	Clone ()

Public Attributes
IEnumerable< TriangleGroup >	Groups => _triangles.Select(x => x.Group).Where(x => x != null).Distinct()

Protected Member Functions
	Mesh (Mesh mesh)

Properties
IEnumerable< Triangle >	Triangles `[get]`

IEnumerable< Vertex >	Vertices `[get]`

IEnumerable< Material >	Materials `[get]`

int	TriangleCount `[get]`

int	VertexCount `[get]`

bool	Empty `[get]`

Detailed Description

A raw, un-optimize, fully mutable, representation of a static mesh

Constructor & Destructor Documentation

◆ Mesh() [1/3]

pluginbase.Helpers.Mesh.Mesh.Mesh ( bool autoNormals )

         {
             _autoNormal = autoNormals;
         }

◆ Mesh() [2/3]

pluginbase.Helpers.Mesh.Mesh.Mesh ( )

77 :this(false)

78 {}

◆ Mesh() [3/3]

pluginbase.Helpers.Mesh.Mesh.Mesh ( Mesh mesh )

protected

             :this()
         {
             this.Merge(mesh);
         }

Member Function Documentation

◆ AddQuad()

Triangle [] pluginbase.Helpers.Mesh.Mesh.AddQuad	(	Vertex	a,
		Vertex	b,
		Vertex	c,
		Vertex	d,
		Material	material = `null`,
		TriangleGroup	group = `null`
	)

         {
             var tri1 = AddTriangle(a, b, c, material, group);
             var tri2 = AddTriangle(a, c, d, material, group);
             return new[]{tri1, tri2};
         }

◆ AddTriangle() [1/4]

Triangle pluginbase.Helpers.Mesh.Mesh.AddTriangle ( )

         {
             return AddTriangle(new Vertex(), new Vertex(), new Vertex());
         }

◆ AddTriangle() [2/4]

Triangle pluginbase.Helpers.Mesh.Mesh.AddTriangle	(	Vertex []	v,
		Material	mat = `null`
	)

Attribute: 0], v[1], v[2

, mat);

         {
             if (v.Length != 3)
             {
                 throw new ArgumentException("Expected 3 verts");
             }
             return AddTriangle(v[0], v[1], v[2], mat);
         }

◆ AddTriangle() [3/4]

Triangle pluginbase.Helpers.Mesh.Mesh.AddTriangle	(	Vertex	a,
		Vertex	b,
		Vertex	c,
		Material	mat = `null`,
		TriangleGroup	group = `null`
	)

         {
             return AddTriangle( new Triangle
             {
                 A = a,
                 B = b,
                 C = c,
                 Material = mat,
                 Group = group,
             });
         }

◆ AddTriangle() [4/4]

Triangle pluginbase.Helpers.Mesh.Mesh.AddTriangle ( Triangle tri )

         {
             _triangles.Add(tri);
             if (_autoNormal)
             {
                 tri.A.Normal = tri.B.Normal = tri.C.Normal = CalculateNormal ( tri.A.Coordinate, tri.B.Coordinate, tri.C.Coordinate );
             }
 
             return tri;
         }

◆ Clone()

Mesh pluginbase.Helpers.Mesh.Mesh.Clone ( )

         {
             return new Mesh(this);
         }

◆ ComputeBoundingBox()

AxisAlignedBox pluginbase.Helpers.Mesh.Mesh.ComputeBoundingBox ( )

         {
             return AxisAlignedBox.FromPointCloud(this.Vertices.Select(x => x.Coordinate));
         }

◆ ComputeFlatNormals()

void pluginbase.Helpers.Mesh.Mesh.ComputeFlatNormals ( )

Computes the flat normals. Vert fast, but assumes each triangle has its own unique set of vertices

         {
             foreach(var tri in _triangles)
             {
                 tri.A.Normal = tri.B.Normal = tri.C.Normal = CalculateNormal(tri.A.Coordinate, tri.B.Coordinate, tri.C.Coordinate);
             }
         }

◆ ComputeSmoothNormalsByProximity()

void pluginbase.Helpers.Mesh.Mesh.ComputeSmoothNormalsByProximity ( )

Computes the smooth normals by proximity of the coordinate. Slowest, but most accurate, method

         {
             //OPTIMIZE: This will count each proximity-very more than one. There's some optional optimization to do here
             foreach(var vert in this.Vertices)
             {
                 Vector3 sum = Vector3.Zero;
                 foreach(var tri in _triangles)
                 {
                     if ( (tri.A.Coordinate - vert.Coordinate).Length < SAME_BIAS
                         || (tri.B.Coordinate - vert.Coordinate).Length < SAME_BIAS
                         || (tri.C.Coordinate - vert.Coordinate).Length < SAME_BIAS)
                     {
                         sum += CalculateNormal(tri.A.Coordinate, tri.B.Coordinate, tri.C.Coordinate);
                     }
                 }
                 sum.Normalize();
                 vert.Normal = sum;
             }
         }

◆ ComputeSmoothNormalsByRef()

void pluginbase.Helpers.Mesh.Mesh.ComputeSmoothNormalsByRef ( )

Computes the smooth normals by reference. Mid-range speed O(v * t). Only works if vertices are propertly created with references to each other in an indexed way

         {
             foreach(var vert in this.Vertices)
             {
                 Vector3 sum = Vector3.Zero;
                 foreach(var tri in _triangles)
                 {
                     if (tri.A == vert || tri.B == vert || tri.C == vert)
                     {
                         sum += CalculateNormal(tri.A.Coordinate, tri.B.Coordinate, tri.C.Coordinate);
                     }
                 }
                 sum.Normalize();
                 vert.Normal = sum;
             }
         }

◆ Merge()

void pluginbase.Helpers.Mesh.Mesh.Merge ( Mesh mesh )

Merge multiple meshes

Parameters

mesh Mesh.

Attribute: mat

= mat.Clone();

Attribute: vert

= vert.Clone();

Attribute: tri.A

,

Attribute: tri.B

,

Attribute: tri.C

,

Attribute: tri.Material

: null

         {
             var matMap = new Dictionary<Material, Material>();
             var vertMap = new Dictionary<Vertex, Vertex>();
 
             foreach (var mat in mesh.Materials)
             {
                 matMap[mat] = mat.Clone();
             }
             foreach (var vert in mesh.Vertices)
             {
                 vertMap[vert] = vert.Clone();
             }
             foreach (var tri in mesh._triangles)
             {
                 _triangles.Add(new Triangle{
                     A = vertMap[tri.A],
                     B = vertMap[tri.B],
                     C = vertMap[tri.C],
                     Material = tri.Material != null ? matMap[tri.Material] : null
                 });
             }
         }

◆ ReverseVertexOrder()

void pluginbase.Helpers.Mesh.Mesh.ReverseVertexOrder ( )

Flips vertex order on all triangles eg. from (1,2,3) to (3,2,1) Useful when normals are generating backwards

         {
             foreach (var tri in _triangles)
             {
                 var tmp = tri.A;
                 tri.A = tri.C;
                 tri.C = tmp;
             }
         }

◆ TrianglesInGroup() [1/2]

IEnumerable<Triangle> pluginbase.Helpers.Mesh.Mesh.TrianglesInGroup ( TriangleGroup group )

         {
             return _triangles.Where(x => x.Group == group);
         }

◆ TrianglesInGroup() [2/2]

IEnumerable<Triangle> pluginbase.Helpers.Mesh.Mesh.TrianglesInGroup ( string groupName )

         {
             return _triangles.Where(x => x.Group?.Name == groupName);
         }

Member Data Documentation

◆ Groups

IEnumerable<TriangleGroup> pluginbase.Helpers.Mesh.Mesh.Groups => _triangles.Select(x => x.Group).Where(x => x != null).Distinct()

Property Documentation

◆ Empty

bool pluginbase.Helpers.Mesh.Mesh.Empty

get

◆ Materials

IEnumerable<Material> pluginbase.Helpers.Mesh.Mesh.Materials

get

◆ TriangleCount

int pluginbase.Helpers.Mesh.Mesh.TriangleCount

get

◆ Triangles

IEnumerable<Triangle> pluginbase.Helpers.Mesh.Mesh.Triangles

get

◆ VertexCount

int pluginbase.Helpers.Mesh.Mesh.VertexCount

get

◆ Vertices

IEnumerable<Vertex> pluginbase.Helpers.Mesh.Mesh.Vertices

get

The documentation for this class was generated from the following file:

pluginbase/Helpers/Mesh/Mesh.cs

Public Member Functions

Public Attributes

Protected Member Functions

Properties