vcglib/wrap/gl/glu_tesselator.h

267 lines
8.9 KiB
C++

/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#ifndef __VCGLIB_GLU_TESSELATOR_H
#define __VCGLIB_GLU_TESSELATOR_H
#include <vcg/space/point2.h>
#include <vector>
#ifndef GL_VERSION_1_1
#error "Please include OpenGL before including this file"
#endif
// The inclusion of glu should be always safe (if someone has already included gl stuff).
#ifndef GLU_VERSIONS
#ifdef __APPLE__
#include <OpenGL/glu.h>
#else
#ifdef _WIN32
#include <windows.h>
#endif
#include <GL/glu.h>
#endif
#endif
#ifndef CALLBACK
#ifdef _WIN32
#define CALLBACK __stdcall
#else
#define CALLBACK
#endif
#endif
namespace vcg
{
class glu_tesselator
{
public:
typedef glu_tesselator this_type;
/*
Works with Point2 and Point3;
sample usage:
// tesselation input: each outline represents a polygon contour
std::vector< std::vector<point_type> > outlines = ...;
// tesselation output (triangles indices)
std::vector<int> indices;
// compute triangles indices
glu_tesselator::tesselate(outlines, indices);
// unroll input contours points
std::vector<point_type> points;
for (size_t i=0; i<outlines.size(); ++i)
{
for (size_t j=0; j<outlines[i].size(); ++j)
{
points.push_back(outlines[i][j]);
}
}
// or simply call glu_tesselator::unroll(outlines, points);
// create triangles
for (size_t i=0; i<indices.size(); i+=3)
{
create_triangle(
points[ indices[i+0] ],
points[ indices[i+1] ],
points[ indices[i+2] ]);
}
*/
template <class point_type>
static inline void unroll(const std::vector< std::vector<point_type> > & outlines, std::vector<point_type> & points)
{
for (size_t i=0; i<outlines.size(); ++i)
{
for (size_t j=0; j<outlines[i].size(); ++j)
{
points.push_back(outlines[i][j]);
}
}
}
template <class point_type>
static inline void tesselate(const std::vector< std::vector<point_type> > & outlines, std::vector<int> & indices)
{
tess_prim_data_vec t_data;
this_type::do_tesselation(outlines, t_data);
//int k = 0;
for (size_t i=0; i<t_data.size(); ++i)
{
const size_t st = t_data[i].indices.size();
if (st < 3) continue;
switch (t_data[i].type)
{
case GL_TRIANGLES:
for (size_t j=0; j<st; ++j)
{
indices.push_back(t_data[i].indices[j]);
}
break;
case GL_TRIANGLE_STRIP:
{
int i0 = t_data[i].indices[0];
int i1 = t_data[i].indices[1];
bool ccw = true;
for (size_t j=2; j<st; ++j)
{
const int i2 = t_data[i].indices[j];
indices.push_back(i0);
indices.push_back(i1);
indices.push_back(i2);
if (ccw) i0 = i2;
else i1 = i2;
ccw = !ccw;
} }
break;
case GL_TRIANGLE_FAN:
{
const int first = t_data[i].indices[0];
int prev = t_data[i].indices[1];
for (size_t j=2; j<st; ++j)
{
const int curr = t_data[i].indices[j];
indices.push_back(first);
indices.push_back(prev);
indices.push_back(curr);
prev = curr;
}
}
break;
default:
break;
}
}
}
protected:
class tess_prim_data
{
public:
typedef tess_prim_data this_type;
GLenum type;
std::vector<int> indices;
tess_prim_data(void) { }
tess_prim_data(GLenum t) : type(t) { }
};
typedef std::vector<tess_prim_data> tess_prim_data_vec;
static void CALLBACK begin_cb(GLenum type, void * polygon_data)
{
tess_prim_data_vec * t_data = (tess_prim_data_vec *)polygon_data;
t_data->push_back(tess_prim_data(type));
}
static void CALLBACK end_cb(void * polygon_data)
{
(void)polygon_data;
}
static void CALLBACK vertex_cb(void * vertex_data, void * polygon_data)
{
tess_prim_data_vec * t_data = (tess_prim_data_vec *)polygon_data;
t_data->back().indices.push_back((int)((size_t)vertex_data));
}
template <class point_type>
static void do_tesselation(const std::vector< std::vector<point_type> > & outlines, tess_prim_data_vec & t_data)
{
GLUtesselator * tess = gluNewTess();
//#ifdef __APPLE__
// gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLvoid (CALLBACK *)(...))(this_type::begin_cb));
// gluTessCallback(tess, GLU_TESS_END_DATA, (GLvoid (CALLBACK *)(...))(this_type::end_cb));
// gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)(...))(this_type::vertex_cb));
//#else
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLvoid (CALLBACK *)())(this_type::begin_cb));
gluTessCallback(tess, GLU_TESS_END_DATA, (GLvoid (CALLBACK *)())(this_type::end_cb));
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)())(this_type::vertex_cb));
//#endif
void * polygon_data = (void *)(&t_data);
GLdouble vertex[3];
size_t k = 0;
gluTessBeginPolygon(tess, polygon_data);
for (size_t i=0; i<outlines.size(); ++i)
{
gluTessBeginContour(tess);
for (size_t j=0; j<outlines[i].size(); ++j)
{
this_type::get_position(outlines[i][j], vertex);
gluTessVertex(tess, vertex, (void *)k);
++k;
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
gluDeleteTess(tess);
}
template <class scalar_type>
static inline void get_position(const vcg::Point2<scalar_type> & p, GLdouble * d)
{
d[0] = (GLdouble)(p[0]);
d[1] = (GLdouble)(p[1]);
d[2] = (GLdouble)(0);
}
template <class scalar_type>
static inline void get_position(const vcg::Point3<scalar_type> & p, GLdouble * d)
{
d[0] = (GLdouble)(p[0]);
d[1] = (GLdouble)(p[1]);
d[2] = (GLdouble)(p[2]);
}
};
} // end namespace vcg
#endif // __VCGLIB_GLU_TESSELATOR_H