public CloudInCell(IParticleStorage<Particle> particles, IGrid2D grid, IMesh mesh, bool parallel)
 {
     this.particles = particles;
     this.grid = grid;
     this.mesh = mesh;
     this.parallel = parallel;
 }

        public void Smooth(IMesh mesh, int limit)
        {
            var smoothedMesh = (Mesh)mesh;

            var mesher = new GenericMesher(config);
            var predicates = config.Predicates();

            // The smoother should respect the mesh segment splitting behavior.
            this.options.SegmentSplitting = smoothedMesh.behavior.NoBisect;

            // Take a few smoothing rounds (Lloyd's algorithm).
            for (int i = 0; i < limit; i++)
            {
                Step(smoothedMesh, factory, predicates);

                // Actually, we only want to rebuild, if the mesh is no longer
                // Delaunay. Flipping edges could be the right choice instead 
                // of re-triangulating...
                smoothedMesh = (Mesh)mesher.Triangulate(Rebuild(smoothedMesh), options);

                factory.Reset();
            }

            smoothedMesh.CopyTo((Mesh)mesh);
        }

        public CPlayer(IGameObjectManager pObjMan, IEngineCore pEngineCore)
            : base(pObjMan, pEngineCore)
        {
            _fVelocity = 0f;
            uiShotPause = 15;

            ObjType = EGameObjectType.GotPlayer;

            _stPos = new TPoint2(Res.GameVpWidth / 2f, Res.GameVpHeight / 2f);
            _fSize = 150f;
            _fColScale = 0.6f;

            dimPl = new TPoint3(_fSize, _fSize, _fSize);

            IResourceManager pResMan;
            IEngineSubSystem pSubSys;

            pEngineCore.GetSubSystem(E_ENGINE_SUB_SYSTEM.ESS_INPUT, out pSubSys);
            pInput = (IInput)pSubSys;

            pEngineCore.GetSubSystem(E_ENGINE_SUB_SYSTEM.ESS_RESOURCE_MANAGER, out pSubSys);
            pResMan = (IResourceManager)pSubSys;

            IEngineBaseObject pBaseObj;
            pResMan.GetResourceByName(Res.MeshShip, out pBaseObj);
            pMesh = (IMesh)pBaseObj;
            pResMan.GetResourceByName(Res.TexShip, out pBaseObj);
            pTex = (ITexture)pBaseObj;
            pResMan.GetResourceByName(Res.TexSpark, out pBaseObj);
            pTexSpark = (ITexture)pBaseObj;
        }

        public bool Collides(
            Ray testRay, 
            IEnumerable<IMesh> meshes, 
            out Vector3 position, 
            out IMesh hitMesh, 
            bool furthest = false)
        {
            var distance = furthest ? 0f : 10000f;
            var closestPosition = Vector3.Zero;
            IMesh closestMesh = null;

            foreach (var mesh in meshes)
            {
                if (mesh.MeshVertexPositions == null)
                {
                    continue;
                }

                for (var a = 0; a < mesh.MeshIndicies.Length; a += 3)
                {
                    var vertexA = mesh.MeshVertexPositions[mesh.MeshIndicies[a]];
                    var vertexB = mesh.MeshVertexPositions[mesh.MeshIndicies[a + 1]];
                    var vertexC = mesh.MeshVertexPositions[mesh.MeshIndicies[a + 2]];

                    float tempDistance;
                    var point = this.m_Collision.CollidesWithTriangle(
                        testRay,
                        vertexA,
                        vertexB,
                        vertexC,
                        out tempDistance,
                        false);
                    if (point != null)
                    {
                        if (!furthest)
                        {
                            if (tempDistance < distance && tempDistance > 0)
                            {
                                distance = tempDistance;
                                closestPosition = point.Value;
                                closestMesh = mesh;
                            }
                        }
                        else
                        {
                            if (tempDistance > distance && tempDistance > 0)
                            {
                                distance = tempDistance;
                                closestPosition = point.Value;
                                closestMesh = mesh;
                            }
                        }
                    }
                }
            }

            position = closestPosition;
            hitMesh = closestMesh;
            return closestPosition != Vector3.Zero;
        }

        public unsafe bool SetTextureVertices(IMesh maxMesh, MyMesh myMesh)
        {
            bool countChanged = false;

            if (maxMesh.NumTVerts != myMesh.NumTextureCoordinates)
            {
                maxMesh.SetNumTVerts(myMesh.NumTextureCoordinates, false);
                countChanged = true;
            }

            IntPtr p3h = maxMesh.GetTVertPtr(0).NativePointer;
            float* p3 = (float*)p3h.ToPointer();

            int elementsPerVertex = myMesh.TextureCoordinates.Count / myMesh.NumTextureCoordinates;
            switch (elementsPerVertex)
            {
                case 2:
                    for (int i = 0; i < myMesh.NumTextureCoordinates; i++)
                    {
                        p3[(i * 3) + 0] = myMesh.TextureCoordinates[(i * 2) + 0];
                        p3[(i * 3) + 1] = myMesh.TextureCoordinates[(i * 2) + 1];
                        p3[(i * 3) + 2] = 0.0f;
                    };
                    break;
                case 3:
                    Marshal.Copy(myMesh.TextureCoordinates.ToArray(), 0, p3h, myMesh.NumTextureCoordinates * 3);
                    break;
                default:
                    throw new NotImplementedException(("Unable to handle texture coordinates with " + elementsPerVertex + " elements."));
            }

            return countChanged;
        }

 public void Load(IMesh mesh, string filePath)
 {
   using (var streamReader = new StreamReader(filePath))
   {
     Load(streamReader, mesh);
   }
 }

 /// <summary>
 /// Combine this mesh with another.
 /// </summary>
 /// <param name="anotherMesh">Another mesh.</param>
 /// <seealso cref="ConstructiveSolidGeometry.Union"/>
 public virtual void Combine(IMesh anotherMesh)
 {
     BspNode<SplittableTriangle> a = this.ToBspTree();
     BspNode<SplittableTriangle> b = anotherMesh.ToBspTree();
     a.Unite(b);
     this.SetBsp(a);
 }

 public void Write(IMesh mesh, string filename)
 {
     if (mesh.Vertices.Count > 0)
     {
         format.Write(mesh, filename);
     }
 }

        public void Write(IMesh mesh, string filename)
        {
            var writer = new TriangleWriter();

            writer.WritePoly((Mesh)mesh, Path.ChangeExtension(filename, ".poly"));
            writer.WriteElements((Mesh)mesh, Path.ChangeExtension(filename, ".ele"));
        }

 public void Load(IMesh mesh, string filePath)
 {
   var dxfLoad = DxfDocument.Load(filePath);
   var vertices = new List<IVertex>();
   var faces = new List<IFace>();
   var verticesIndexMap = new Dictionary<IVertex, int>();
   int currentVertexIndex = 0;
   foreach (var face3D in dxfLoad.Faces3d)
   {
     var v1 = face3D.FirstVertex;
     var v2 = face3D.SecondVertex;
     var v3 = face3D.ThirdVertex;
     var v4 = face3D.FourthVertex;
     currentVertexIndex = CreateTriangleFace(v1, v2, v3, verticesIndexMap, currentVertexIndex, vertices, faces);
     currentVertexIndex = CreateTriangleFace(v3, v4, v1, verticesIndexMap, currentVertexIndex, vertices, faces);
   }
   foreach (var vertex in vertices)
   {
     mesh.AddVertex(vertex);
   }
   foreach (var face in faces)
   {
     mesh.AddFace(face);
   }
 }

        public static VNormal[] ComputeNormals(IMesh mesh)
        {
            var vnorms = new VNormal[mesh.NumVerts];
            var fnorms = new Vector3[mesh.NumFaces];

            for (var index = 0; index < mesh.NumVerts; index++)
            {
                vnorms[index] = new VNormal();
            }

            for (var index = 0; index < mesh.NumFaces; index++)
            {
                var face = mesh.Faces[index];
                Vector3 v0 = mesh.Verts[(int)face.V[0]].ToVector3();
                Vector3 v1 = mesh.Verts[(int)face.V[1]].ToVector3();
                Vector3 v2 = mesh.Verts[(int)face.V[2]].ToVector3();

                fnorms[index] = Vector3.Cross((v1 - v0), (v2 - v1));

                for (var j = 0; j < 3; j++)
                {
                    vnorms[(int)face.V[j]].AddNormal(fnorms[index], face.SmGroup);
                }

                fnorms[index].Normalize();
            }

            for (var index = 0; index < mesh.NumVerts; index++)
            {
                vnorms[index].Normalize();
            }

            return vnorms;
        }

 public void DestroyMesh(ref IMesh _OutMesh)
 {
     if (m_MeshInstanceContainer.ContainsKey(_OutMesh.m_InstanceID)) {
         m_MeshInstanceContainer[_OutMesh.m_InstanceID].Release();
         m_MeshInstanceContainer.Remove(_OutMesh.m_InstanceID);
         _OutMesh = null;
     }
 }

 /// <summary>
 /// Subtracts another mesh from this one.
 /// </summary>
 /// <param name="anotherMesh">Another mesh.</param>
 /// <seealso cref="ConstructiveSolidGeometry.Subtract"/>
 public virtual void Subtract(IMesh anotherMesh)
 {
     BspNode<SplittableTriangle> a = this.ToBspTree();
     BspNode<SplittableTriangle> b = anotherMesh.ToBspTree();
     a.Invert();
     a.Unite(b);
     a.Invert();
     this.SetBsp(a);
 }

 public PICMonitor(IGrid2D grid, IMesh mesh, IParticleStorage<Particle> particles, IPICSolver solver)
 {
     this.grid = grid;
     this.particles = particles;
     this.mesh = mesh;
     this.solver = solver;
     GridX = grid.X;
     GridY = grid.Y;
     Status = PICStatus.Created;
 }

    public static Vector3[] vertexPositions(IMesh mesh){

      Vector3[] positions = new Vector3[mesh.VerticesCount];
      int i = 0;
      foreach(IVertex v in mesh.Vertices) {
        positions [i] = v.Position;
        i++;
      }
      return positions;
    }

 // copy
 public Mesh_VoxelChunk(IMesh _CopyMesh) : base(_CopyMesh)
 {
     Mesh_VoxelChunk _copyVoxelChunk = _CopyMesh as Mesh_VoxelChunk;
     if (_copyVoxelChunk.HasChunk)
     {
         m_ChunkMap = new Dictionary<string, Chunk>(_copyVoxelChunk.ChunkMap);
     }
     if (_copyVoxelChunk.HasModel)
     {
         m_ModelMap = new Dictionary<string, Chunk>(_copyVoxelChunk.ModelMap);
     }
 }

    public static uint[] faceIndices(IMesh mesh){

      uint[] faces = new uint[mesh.FacesCount * 3];
      int i = 0;
      foreach (IFace f in mesh.Faces) {
        foreach (int indx in f.VertexIndices) {
          faces [i] = (uint)indx;
          i++;
        }
      }
      return faces;
    }

        public bool SetPositionVertices(IMesh maxMesh, MyMesh myMesh)
        {
            bool countChanged = false;

            if (maxMesh.NumVerts != myMesh.NumVertices)
            {
                maxMesh.SetNumVerts(myMesh.NumVertices, false, false);
                countChanged = true;
            }

            IPoint3 p3 = maxMesh.GetVertPtr(0);
            Marshal.Copy(myMesh.Vertices.ToArray(), 0, p3.NativePointer, myMesh.NumVertices * 3);

            return countChanged;
        }

        public BiologicalEquation(IMesh mesh)
        {
            this.mesh = mesh;

            k = 17;
            Kb = 0.0005;
            Km = 0.0005;
            r = 0.2;
            mmu = 1.5;
            nnu = 0;
            zet = 0;
            c1 = 0;
            c2 = 0;
            dt = 0.0416667;
            // TODO: Take from args.
        }

 /// <summary>
 /// Intersects this mesh with another.
 /// </summary>
 /// <param name="anotherMesh">Another mesh.</param>
 /// <seealso cref="ConstructiveSolidGeometry.Intersection"/>
 public virtual void Intersect(IMesh anotherMesh)
 {
     BspNode<SplittableTriangle> a = this.ToBspTree();
     BspNode<SplittableTriangle> b = anotherMesh.ToBspTree();
     a.Invert();				// Cut geometry that is not common for the meshes.
     b.CutTreeOut(a);		//
     b.Invert();				//
     a.CutTreeOut(b);		//
     // Clean up remains.
     b.CutTreeOut(a);
     // Combine geometry.
     a.AddElements(b.AllElements);
     // Invert everything.
     a.Invert();
     this.SetBsp(a);
 }