changed int -> size_t to remove warnings

This commit is contained in:
Paolo Cignoni 2013-12-12 20:52:07 +00:00
parent 43b738796d
commit d44d6e6f41
1 changed files with 160 additions and 160 deletions

View File

@ -55,210 +55,210 @@ namespace vcg
class glu_tesselator class glu_tesselator
{ {
public: public:
typedef glu_tesselator this_type; typedef glu_tesselator this_type;
/* /*
Works with Point2 and Point3; Works with Point2 and Point3;
sample usage: sample usage:
// tesselation input: each outline represents a polygon contour // tesselation input: each outline represents a polygon contour
std::vector< std::vector<point_type> > outlines = ...; std::vector< std::vector<point_type> > outlines = ...;
// tesselation output (triangles indices) // tesselation output (triangles indices)
std::vector<int> indices; std::vector<int> indices;
// compute triangles indices // compute triangles indices
glu_tesselator::tesselate(outlines, indices); glu_tesselator::tesselate(outlines, indices);
// unroll input contours points // unroll input contours points
std::vector<point_type> points; std::vector<point_type> points;
for (size_t i=0; i<outlines.size(); ++i) for (size_t i=0; i<outlines.size(); ++i)
{ {
for (size_t j=0; j<outlines[i].size(); ++j) for (size_t j=0; j<outlines[i].size(); ++j)
{ {
points.push_back(outlines[i][j]); points.push_back(outlines[i][j]);
} }
} }
// or simply call glu_tesselator::unroll(outlines, points); // or simply call glu_tesselator::unroll(outlines, points);
// create triangles // create triangles
for (size_t i=0; i<indices.size(); i+=3) for (size_t i=0; i<indices.size(); i+=3)
{ {
create_triangle( create_triangle(
points[ indices[i+0] ], points[ indices[i+0] ],
points[ indices[i+1] ], points[ indices[i+1] ],
points[ indices[i+2] ]); points[ indices[i+2] ]);
} }
*/ */
template <class point_type> template <class point_type>
static inline void unroll(const std::vector< std::vector<point_type> > & outlines, std::vector<point_type> & points) 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 i=0; i<outlines.size(); ++i)
{ {
for (size_t j=0; j<outlines[i].size(); ++j) for (size_t j=0; j<outlines[i].size(); ++j)
{ {
points.push_back(outlines[i][j]); points.push_back(outlines[i][j]);
} }
} }
} }
template <class point_type> template <class point_type>
static inline void tesselate(const std::vector< std::vector<point_type> > & outlines, std::vector<int> & indices) static inline void tesselate(const std::vector< std::vector<point_type> > & outlines, std::vector<int> & indices)
{ {
tess_prim_data_vec t_data; tess_prim_data_vec t_data;
this_type::do_tesselation(outlines, t_data); this_type::do_tesselation(outlines, t_data);
//int k = 0; //int k = 0;
for (size_t i=0; i<t_data.size(); ++i) for (size_t i=0; i<t_data.size(); ++i)
{ {
const size_t st = t_data[i].indices.size(); const size_t st = t_data[i].indices.size();
if (st < 3) continue; if (st < 3) continue;
switch (t_data[i].type) switch (t_data[i].type)
{ {
case GL_TRIANGLES: case GL_TRIANGLES:
for (size_t j=0; j<st; ++j) for (size_t j=0; j<st; ++j)
{ {
indices.push_back(t_data[i].indices[j]); indices.push_back(t_data[i].indices[j]);
} }
break; break;
case GL_TRIANGLE_STRIP: case GL_TRIANGLE_STRIP:
{ {
int i0 = t_data[i].indices[0]; int i0 = t_data[i].indices[0];
int i1 = t_data[i].indices[1]; int i1 = t_data[i].indices[1];
bool ccw = true; bool ccw = true;
for (size_t j=2; j<st; ++j) for (size_t j=2; j<st; ++j)
{ {
const int i2 = t_data[i].indices[j]; const int i2 = t_data[i].indices[j];
indices.push_back(i0); indices.push_back(i0);
indices.push_back(i1); indices.push_back(i1);
indices.push_back(i2); indices.push_back(i2);
if (ccw) i0 = i2; if (ccw) i0 = i2;
else i1 = i2; else i1 = i2;
ccw = !ccw; ccw = !ccw;
} } } }
break; break;
case GL_TRIANGLE_FAN: case GL_TRIANGLE_FAN:
{ {
const int first = t_data[i].indices[0]; const int first = t_data[i].indices[0];
int prev = t_data[i].indices[1]; int prev = t_data[i].indices[1];
for (size_t j=2; j<st; ++j) for (size_t j=2; j<st; ++j)
{ {
const int curr = t_data[i].indices[j]; const int curr = t_data[i].indices[j];
indices.push_back(first); indices.push_back(first);
indices.push_back(prev); indices.push_back(prev);
indices.push_back(curr); indices.push_back(curr);
prev = curr; prev = curr;
} }
} }
break; break;
default: default:
break; break;
} }
} }
} }
protected: protected:
class tess_prim_data class tess_prim_data
{ {
public: public:
typedef tess_prim_data this_type; typedef tess_prim_data this_type;
GLenum type; GLenum type;
std::vector<int> indices; std::vector<int> indices;
tess_prim_data(void) { } tess_prim_data(void) { }
tess_prim_data(GLenum t) : type(t) { } tess_prim_data(GLenum t) : type(t) { }
}; };
typedef std::vector<tess_prim_data> tess_prim_data_vec; typedef std::vector<tess_prim_data> tess_prim_data_vec;
static void CALLBACK begin_cb(GLenum type, void * polygon_data) static void CALLBACK begin_cb(GLenum type, void * polygon_data)
{ {
tess_prim_data_vec * t_data = (tess_prim_data_vec *)polygon_data; tess_prim_data_vec * t_data = (tess_prim_data_vec *)polygon_data;
t_data->push_back(tess_prim_data(type)); t_data->push_back(tess_prim_data(type));
} }
static void CALLBACK end_cb(void * polygon_data) static void CALLBACK end_cb(void * polygon_data)
{ {
(void)polygon_data; (void)polygon_data;
} }
static void CALLBACK vertex_cb(void * vertex_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; tess_prim_data_vec * t_data = (tess_prim_data_vec *)polygon_data;
t_data->back().indices.push_back((int)((size_t)vertex_data)); t_data->back().indices.push_back((int)((size_t)vertex_data));
} }
template <class point_type> template <class point_type>
static void do_tesselation(const std::vector< std::vector<point_type> > & outlines, tess_prim_data_vec & t_data) static void do_tesselation(const std::vector< std::vector<point_type> > & outlines, tess_prim_data_vec & t_data)
{ {
GLUtesselator * tess = gluNewTess(); GLUtesselator * tess = gluNewTess();
//#ifdef __APPLE__ //#ifdef __APPLE__
// gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLvoid (CALLBACK *)(...))(this_type::begin_cb)); // 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_END_DATA, (GLvoid (CALLBACK *)(...))(this_type::end_cb));
// gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)(...))(this_type::vertex_cb)); // gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)(...))(this_type::vertex_cb));
//#else //#else
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLvoid (CALLBACK *)())(this_type::begin_cb)); 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_END_DATA, (GLvoid (CALLBACK *)())(this_type::end_cb));
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)())(this_type::vertex_cb)); gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLvoid (CALLBACK *)())(this_type::vertex_cb));
//#endif //#endif
void * polygon_data = (void *)(&t_data); void * polygon_data = (void *)(&t_data);
GLdouble vertex[3]; GLdouble vertex[3];
int k = 0; size_t k = 0;
gluTessBeginPolygon(tess, polygon_data); gluTessBeginPolygon(tess, polygon_data);
for (size_t i=0; i<outlines.size(); ++i) for (size_t i=0; i<outlines.size(); ++i)
{ {
gluTessBeginContour(tess); gluTessBeginContour(tess);
for (size_t j=0; j<outlines[i].size(); ++j) for (size_t j=0; j<outlines[i].size(); ++j)
{ {
this_type::get_position(outlines[i][j], vertex); this_type::get_position(outlines[i][j], vertex);
gluTessVertex(tess, vertex, (void *)k); gluTessVertex(tess, vertex, (void *)k);
++k; ++k;
} }
gluTessEndContour(tess); gluTessEndContour(tess);
} }
gluTessEndPolygon(tess); gluTessEndPolygon(tess);
gluDeleteTess(tess); gluDeleteTess(tess);
} }
template <class scalar_type> template <class scalar_type>
static inline void get_position(const vcg::Point2<scalar_type> & p, GLdouble * d) static inline void get_position(const vcg::Point2<scalar_type> & p, GLdouble * d)
{ {
d[0] = (GLdouble)(p[0]); d[0] = (GLdouble)(p[0]);
d[1] = (GLdouble)(p[1]); d[1] = (GLdouble)(p[1]);
d[2] = (GLdouble)(0); d[2] = (GLdouble)(0);
} }
template <class scalar_type> template <class scalar_type>
static inline void get_position(const vcg::Point3<scalar_type> & p, GLdouble * d) static inline void get_position(const vcg::Point3<scalar_type> & p, GLdouble * d)
{ {
d[0] = (GLdouble)(p[0]); d[0] = (GLdouble)(p[0]);
d[1] = (GLdouble)(p[1]); d[1] = (GLdouble)(p[1]);
d[2] = (GLdouble)(p[2]); d[2] = (GLdouble)(p[2]);
} }
}; };
} // end namespace vcg } // end namespace vcg