Slic3r::GluTessWrapper Class Reference

Collaboration diagram for Slic3r::GluTessWrapper:

Public Member Functions
	GluTessWrapper ()
	~GluTessWrapper ()
std::vector< Vec3d >	tesselate3d (const ExPolygon &expoly, double z_, bool flipped_)
std::vector< Vec3d >	tesselate3d (const ExPolygons &expolygons, double z_, bool flipped_)

Private Member Functions
void	tessBegin (GLenum which)
void	tessEnd ()
void	tessVertex (const GLvoid *data)
void	tessCombine (const GLdouble newVertex[3], const GLdouble *neighborVertex[4], const GLfloat neighborWeight[4], GLdouble **outData)

Static Private Member Functions
static void	tessBeginCB (GLenum which, void *polygonData)
static void	tessEndCB (void *polygonData)
static void	tessVertexCB (const GLvoid *data, void *polygonData)
static void	tessCombineCB (const GLdouble newVertex[3], const GLdouble *neighborVertex[4], const GLfloat neighborWeight[4], GLdouble **outData, void *polygonData)
static void	tessErrorCB (GLenum errorCode, void *polygonData)
static void	tessError (GLenum errorCode)

Private Attributes
GLUtesselator *	m_tesselator
GLenum	m_primitive_type
GLdouble	m_pt0 [3]
GLdouble	m_pt1 [3]
int	m_num_points
Pointf3s	m_output_triangles
std::deque< Vec3d >	m_intersection_points
double	m_z
bool	m_flipped

Detailed Description

Constructor & Destructor Documentation

GluTessWrapper()

Slic3r::GluTessWrapper::GluTessWrapper ( )

inline

                     : m_tesselator(gluNewTess()) {
        // register callback functions
        gluTessCallback(m_tesselator, GLU_TESS_BEGIN_DATA,   (_GLUfuncptr)tessBeginCB);
        gluTessCallback(m_tesselator, GLU_TESS_END_DATA,     (_GLUfuncptr)tessEndCB);
        gluTessCallback(m_tesselator, GLU_TESS_ERROR_DATA,   (_GLUfuncptr)tessErrorCB);
        gluTessCallback(m_tesselator, GLU_TESS_VERTEX_DATA,  (_GLUfuncptr)tessVertexCB);
        gluTessCallback(m_tesselator, GLU_TESS_COMBINE_DATA, (_GLUfuncptr)tessCombineCB);        
    }

References GLU_TESS_BEGIN_DATA, GLU_TESS_COMBINE_DATA, GLU_TESS_END_DATA, GLU_TESS_ERROR_DATA, GLU_TESS_VERTEX_DATA, gluTessCallback, m_tesselator, tessBeginCB(), tessCombineCB(), tessEndCB(), tessErrorCB(), and tessVertexCB().

Here is the call graph for this function:

~GluTessWrapper()

Slic3r::GluTessWrapper::~GluTessWrapper ( )

inline

                      {
        gluDeleteTess(m_tesselator);
    }

References gluDeleteTess, and m_tesselator.

Member Function Documentation

tessBegin()

void Slic3r::GluTessWrapper::tessBegin ( GLenum  which )

inlineprivate

    {
        assert(which == GL_TRIANGLES || which == GL_TRIANGLE_FAN || which == GL_TRIANGLE_STRIP);
        m_primitive_type = which;
        m_num_points = 0;
    }

References GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP, GL_TRIANGLES, m_num_points, and m_primitive_type.

Referenced by tessBeginCB().

Here is the caller graph for this function:

tessBeginCB()

static void Slic3r::GluTessWrapper::tessBeginCB ( GLenum  which, void *  polygonData  )

inlinestaticprivate

{ reinterpret_cast<GluTessWrapper*>(polygonData)->tessBegin(which); }

References tessBegin().

Referenced by GluTessWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tessCombine()

void Slic3r::GluTessWrapper::tessCombine ( const GLdouble  newVertex[3], const GLdouble *  neighborVertex[4], const GLfloat  neighborWeight[4], GLdouble **  outData  )

inlineprivate

    {
        m_intersection_points.emplace_back(newVertex[0], newVertex[1], m_z);
        *outData = m_intersection_points.back().data();
    }

References m_intersection_points, and m_z.

Referenced by tessCombineCB().

Here is the caller graph for this function:

tessCombineCB()

static void Slic3r::GluTessWrapper::tessCombineCB ( const GLdouble  newVertex[3], const GLdouble *  neighborVertex[4], const GLfloat  neighborWeight[4], GLdouble **  outData, void *  polygonData  )

inlinestaticprivate

                                                                    { reinterpret_cast<GluTessWrapper*>(polygonData)->tessCombine(newVertex, neighborVertex, neighborWeight, outData); }

References tessCombine().

Referenced by GluTessWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tesselate3d() [1/2]

std::vector< Vec3d > Slic3r::GluTessWrapper::tesselate3d ( const ExPolygon &  expoly, double  z_, bool  flipped_  )

inline

    {
        m_z = z_;
        m_flipped = flipped_;
        m_output_triangles.clear();
        std::vector<GLdouble> coords;
        {
            size_t num_coords = expoly.contour.points.size();
            for (const Polygon &poly : expoly.holes)
                num_coords += poly.points.size();
            coords.reserve(num_coords * 3);
        }
        gluTessBeginPolygon(m_tesselator, (void*)this);
        gluTessBeginContour(m_tesselator);
        for (const Point &pt : expoly.contour.points) {
            coords.emplace_back(unscale<double>(pt[0]));
            coords.emplace_back(unscale<double>(pt[1]));
            coords.emplace_back(0.);
            gluTessVertex(m_tesselator, &coords[coords.size() - 3], &coords[coords.size() - 3]);
        }
        gluTessEndContour(m_tesselator);
        for (const Polygon &poly : expoly.holes) {
            gluTessBeginContour(m_tesselator);
            for (const Point &pt : poly.points) {
                coords.emplace_back(unscale<double>(pt[0]));
                coords.emplace_back(unscale<double>(pt[1]));
                coords.emplace_back(0.);
                gluTessVertex(m_tesselator, &coords[coords.size() - 3], &coords[coords.size() - 3]);
            }
            gluTessEndContour(m_tesselator);
        }
        gluTessEndPolygon(m_tesselator);
        m_intersection_points.clear();
        return std::move(m_output_triangles);
    }

References Slic3r::ExPolygon::contour, gluTessBeginContour, gluTessBeginPolygon, gluTessEndContour, gluTessEndPolygon, gluTessVertex, Slic3r::ExPolygon::holes, m_flipped, m_intersection_points, m_output_triangles, m_tesselator, m_z, and Slic3r::MultiPoint::points.

Referenced by Slic3r::triangulate_expolygon_2d(), Slic3r::triangulate_expolygon_2f(), Slic3r::triangulate_expolygon_3d(), Slic3r::triangulate_expolygons_2d(), Slic3r::triangulate_expolygons_2f(), and Slic3r::triangulate_expolygons_3d().

Here is the caller graph for this function:

tesselate3d() [2/2]

std::vector< Vec3d > Slic3r::GluTessWrapper::tesselate3d ( const ExPolygons &  expolygons, double  z_, bool  flipped_  )

inline

    {
        m_z = z_;
        m_flipped = flipped_;
        m_output_triangles.clear();
        std::vector<GLdouble> coords;
        {
            size_t num_coords = 0;
            for (const ExPolygon &expoly : expolygons) {
                size_t num_coords_this = expoly.contour.points.size();
                for (const Polygon &poly : expoly.holes)
                    num_coords_this += poly.points.size();
                num_coords = std::max(num_coords, num_coords_this);
            }
            coords.assign(num_coords * 3, 0);
        }
        for (const ExPolygon &expoly : expolygons) {
            gluTessBeginPolygon(m_tesselator, (void*)this);
            gluTessBeginContour(m_tesselator);
            size_t idx = 0;
            for (const Point &pt : expoly.contour.points) {
                coords[idx ++] = unscale<double>(pt[0]);
                coords[idx ++] = unscale<double>(pt[1]);
                coords[idx ++] = 0.;
                gluTessVertex(m_tesselator, &coords[idx - 3], &coords[idx - 3]);
            }
            gluTessEndContour(m_tesselator);
            for (const Polygon &poly : expoly.holes) {
                gluTessBeginContour(m_tesselator);
                for (const Point &pt : poly.points) {
                    coords[idx ++] = unscale<double>(pt[0]);
                    coords[idx ++] = unscale<double>(pt[1]);
                    coords[idx ++] = 0.;
                    gluTessVertex(m_tesselator, &coords[idx - 3], &coords[idx - 3]);
                }
                gluTessEndContour(m_tesselator);
            }
            gluTessEndPolygon(m_tesselator);
        }
        m_intersection_points.clear();
        return std::move(m_output_triangles);
    }

References gluTessBeginContour, gluTessBeginPolygon, gluTessEndContour, gluTessEndPolygon, gluTessVertex, m_flipped, m_intersection_points, m_output_triangles, m_tesselator, and m_z.

tessEnd()

void Slic3r::GluTessWrapper::tessEnd ( )

inlineprivate

    {
        m_num_points = 0;
    }

References m_num_points.

Referenced by tessEndCB().

Here is the caller graph for this function:

tessEndCB()

static void Slic3r::GluTessWrapper::tessEndCB ( void *  polygonData )

inlinestaticprivate

{ reinterpret_cast<GluTessWrapper*>(polygonData)->tessEnd(); }

References tessEnd().

Referenced by GluTessWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tessError()

static void Slic3r::GluTessWrapper::tessError ( GLenum  errorCode )

inlinestaticprivate

    {
//        const GLubyte *errorStr;
//        errorStr = gluErrorString(errorCode);
//        printf("Error: %s\n", (const char*)errorStr);
    }

Referenced by tessErrorCB().

Here is the caller graph for this function:

tessErrorCB()

static void Slic3r::GluTessWrapper::tessErrorCB ( GLenum  errorCode, void *  polygonData  )

inlinestaticprivate

{ reinterpret_cast<GluTessWrapper*>(polygonData)->tessError(errorCode); }

References tessError().

Referenced by GluTessWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tessVertex()

void Slic3r::GluTessWrapper::tessVertex ( const GLvoid *  data )

inlineprivate

    {
        if (data == nullptr)
            return;
        const GLdouble *ptr = (const GLdouble*)data;
        ++ m_num_points;
        if (m_num_points == 1) {
            memcpy(m_pt0, ptr, sizeof(GLdouble) * 3);
        } else if (m_num_points == 2) {
            memcpy(m_pt1, ptr, sizeof(GLdouble) * 3);
        } else {
            bool flip = m_flipped;
            if (m_primitive_type == GL_TRIANGLE_STRIP && m_num_points == 4) {
                flip = !flip;
                m_num_points = 2;
            }
            m_output_triangles.emplace_back(m_pt0[0], m_pt0[1], m_z);
            if (flip) {
                m_output_triangles.emplace_back(ptr[0],   ptr[1],   m_z);
                m_output_triangles.emplace_back(m_pt1[0], m_pt1[1], m_z);
            } else {
                m_output_triangles.emplace_back(m_pt1[0], m_pt1[1], m_z);
                m_output_triangles.emplace_back(ptr[0],   ptr[1],   m_z);
            }
            if (m_primitive_type == GL_TRIANGLE_STRIP) {
                memcpy(m_pt0, m_pt1, sizeof(GLdouble) * 3);
                memcpy(m_pt1, ptr,   sizeof(GLdouble) * 3);
            } else if (m_primitive_type == GL_TRIANGLE_FAN) {
                memcpy(m_pt1, ptr,   sizeof(GLdouble) * 3);
            } else {
                assert(m_primitive_type == GL_TRIANGLES);
                assert(m_num_points == 3);
                m_num_points = 0;
            }
        }
    }

References GL_TRIANGLE_FAN, GL_TRIANGLE_STRIP, GL_TRIANGLES, m_flipped, m_num_points, m_output_triangles, m_primitive_type, m_pt0, m_pt1, and m_z.

Referenced by tessVertexCB().

Here is the caller graph for this function:

tessVertexCB()

static void Slic3r::GluTessWrapper::tessVertexCB ( const GLvoid *  data, void *  polygonData  )

inlinestaticprivate

{ reinterpret_cast<GluTessWrapper*>(polygonData)->tessVertex(data); }

References tessVertex().

Referenced by GluTessWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_flipped

bool Slic3r::GluTessWrapper::m_flipped

private

Referenced by tesselate3d(), tesselate3d(), and tessVertex().

m_intersection_points

std::deque<Vec3d> Slic3r::GluTessWrapper::m_intersection_points

private

Referenced by tessCombine(), tesselate3d(), and tesselate3d().

m_num_points

int Slic3r::GluTessWrapper::m_num_points

private

Referenced by tessBegin(), tessEnd(), and tessVertex().

m_output_triangles

Pointf3s Slic3r::GluTessWrapper::m_output_triangles

private

Referenced by tesselate3d(), tesselate3d(), and tessVertex().

m_primitive_type

GLenum Slic3r::GluTessWrapper::m_primitive_type

private

Referenced by tessBegin(), and tessVertex().

m_pt0

GLdouble Slic3r::GluTessWrapper::m_pt0[3]

private

Referenced by tessVertex().

m_pt1

GLdouble Slic3r::GluTessWrapper::m_pt1[3]

private

Referenced by tessVertex().

m_tesselator

GLUtesselator* Slic3r::GluTessWrapper::m_tesselator

private

Referenced by GluTessWrapper(), ~GluTessWrapper(), tesselate3d(), and tesselate3d().

m_z

double Slic3r::GluTessWrapper::m_z

private

Referenced by tessCombine(), tesselate3d(), tesselate3d(), and tessVertex().

---

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

• src/libslic3r/Tesselate.cpp