/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/Geometry/Polygonizer.h

/**********************************************************************

polygonizer.h

This is Jules Bloomenthal's implicit surface polygonizer from GRAPHICS 
GEMS IV. Bloomenthal's polygonizer is still used and the present code
is simply the original code morphed into C++.

J. Andreas Brentzen 2003.

**********************************************************************/

#ifndef __GEOMETRY_POLYGONIZER_H
#define __GEOMETRY_POLYGONIZER_H

#include <vector>

namespace Geometry
{

        enum ToTetraHedralize
                {
                        TET = 0,  // use tetrahedral decomposition 
                        NOTET = 1  // no tetrahedral decomposition  */
                };

        class ImplicitFunction
                {
                public:
                        virtual float eval(float,float,float) = 0;
                };

        struct POINT { float x, y, z;   };

        typedef POINT VERTEX;
        typedef POINT NORMAL;

        struct TRIANGLE
        {
                int v0,v1,v2;
        };

        class Polygonizer
                {
                        std::vector<NORMAL> gnormals;  
                        std::vector<VERTEX> gvertices;  
                        std::vector<TRIANGLE> gtriangles;
  
                        ImplicitFunction* func;
                        float size;
                        int bounds;
                        
                        bool use_tetra;
                        bool use_normals;

                public: 
        
                        Polygonizer(ImplicitFunction* _func, float _size, int _bounds,
                                                                        bool _use_tetra=false,
                                                                        bool _use_normals=false):
                                func(_func), size(_size), bounds(_bounds),
                                use_tetra(_use_tetra),
                                use_normals(_use_normals) {}

                        void march(float x, float y, float z);

                        int no_triangles() const
                                {
                                        return gtriangles.size();
                                }

                        int no_vertices() const
                                {
                                        return gvertices.size();
                                }
        
                        int no_normals() const
                                {
                                        return gnormals.size();
                                }
        
                                TRIANGLE& get_triangle(int i) 
                                        {
                                                return gtriangles[i];
                                        }

                                        VERTEX& get_vertex(int i) 
                                                {
                                                        return gvertices[i];
                                                }
        
        
                                                NORMAL& get_normal(int i) 
                                                        {
                                                                return gnormals[i];
                                                        }


                };
}

#endif