/// \brief drop the MillingCutter at Point cl down along the z-axis until it makes contact with Triangle t.
        /// This function calls vertexDrop, facetDrop, and edgeDrop to do its job.
        /// Follows the template-method, or "self-delegation" design pattern.
        /// if cl.z is too low, updates cl.z so that the cutter does not cut Triangle t.

        // call vertex, facet, and edge drop methods on input Triangle t
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: bool dropCutter(CLPoint &cl, const Triangle &t) const
        public bool dropCutter(CLPoint cl, Triangle t)
        {
            bool facet  = false;
            bool vertex = false;
            bool edge   = false;

            /* // alternative ordering of the tests:
             * if (cl.below(t))
             *  vertexDrop(cl,t);
             *
             * // optimisation: if we are now above the triangle we don't need facet and edge
             * if ( cl.below(t) ) {
             *  facetDrop(cl,t);
             *  edgeDrop(cl,t);
             * }*/

            if (cl.below(t))
            {
                facet = facetDrop(cl, t); // if we make contact with the facet...
                if (!facet)
                {                         // ...then we will not hit an edge/vertex, so don't check for that
                    vertex = vertexDrop(cl, t);
                    if (cl.below(t))
                    {
                        edge = edgeDrop(cl, t);
                    }
                }
            }

            return(facet || vertex || edge);
        }
        /// first simple implementation of this operation

        // use OpenMP to share work between threads
        protected void pointDropCutter1(CLPoint clp)
        {
            nCalls = 0;
            int calls = 0;
            LinkedList <Triangle> tris;

            //tris=new std::list<Triangle>();
            tris = root.search_cutter_overlap(cutter, clp);
            LinkedList <Triangle> .Enumerator it;
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
            for (it = tris.GetEnumerator(); it != tris.end(); ++it)
            {             // loop over found triangles
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                if (cutter.overlaps(clp, it))
                {                 // cutter overlap triangle? check
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                    if (clp.below(it))
                    {
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
                        cutter.dropCutter(clp, it);
                        ++calls;
                    }
                }
            }

            /*
             *          delete(tris);
             */
            nCalls = calls;
            return;
        }