void ODDC::DrawPolygonsTessellated( int n, int npoints[], wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
if( dc ) {
int prev = 0;
for( int i = 0; i < n; i++ ) {
dc->DrawPolygon( npoints[i], &points[i + prev], xoffset, yoffset );
prev += npoints[i];
}
}
#ifdef ocpnUSE_GL
else {
GLUtesselator *tobj = gluNewTess();
gluTessCallback( tobj, GLU_TESS_VERTEX, (_GLUfuncptr) &ODDCvertexCallback );
gluTessCallback( tobj, GLU_TESS_BEGIN, (_GLUfuncptr) &ODDCbeginCallback );
gluTessCallback( tobj, GLU_TESS_END, (_GLUfuncptr) &ODDCendCallback );
gluTessCallback( tobj, GLU_TESS_COMBINE, (_GLUfuncptr) &ODDCcombineCallback );
gluTessCallback( tobj, GLU_TESS_ERROR, (_GLUfuncptr) &ODDCerrorCallback );
gluTessNormal( tobj, 0, 0, 1);
gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
gluTessProperty(tobj, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);
if(glIsEnabled(GL_TEXTURE_2D)) g_bTexture2D = true;
else g_bTexture2D = false;
ConfigurePen();
if( ConfigureBrush() ) {
gluTessBeginPolygon(tobj, NULL);
int prev = 0;
for( int j = 0; j < n; j++ ) {
gluTessBeginContour(tobj);
for( int i = 0; i < npoints[j]; i++ ) {
GLvertex* vertex = new GLvertex();
gTesselatorVertices.Add( vertex );
vertex->info.x = (GLdouble) points[i + prev].x;
vertex->info.y = (GLdouble) points[i + prev].y;
vertex->info.z = (GLdouble) 0.0;
vertex->info.r = (GLdouble) 0.0;
vertex->info.g = (GLdouble) 0.0;
vertex->info.b = (GLdouble) 0.0;
vertex->info.a = (GLdouble) 0.0;
gluTessVertex( tobj, (GLdouble*)vertex, (GLdouble*)vertex );
}
gluTessEndContour( tobj );
prev += npoints[j];
}
gluTessEndPolygon(tobj);
}
gluDeleteTess(tobj);
for (unsigned int i = 0; i<gTesselatorVertices.Count(); i++)
delete (GLvertex*)gTesselatorVertices.Item(i);
gTesselatorVertices.Clear();
}
#endif
}
gboolean on_expose(GtkWidget *drawing, GdkEventExpose *event, gpointer _)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1,1, -1,1, 10,-10);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -5);
glEnable(GL_COLOR_MATERIAL);
glDisable(GL_TEXTURE_2D);
glColor3f(1.0, 1.0, 1.0);
/* Create vertexes */
double verts[20][3];
for (int i = 0; i < G_N_ELEMENTS(verts); i++) {
float ang = 2*G_PI * i / G_N_ELEMENTS(verts);
verts[i][0] = sin(ang) * (i%2+0.5) * 0.6;
verts[i][1] = cos(ang) * (i%2+0.5) * 0.6;
verts[i][2] = 0;
}
/* Draw raw polygon */
glColor4f(0.5, 0.0, 0.0, 1.0);
GLUtesselator *tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, glBegin);
gluTessCallback(tess, GLU_TESS_VERTEX, glVertex3dv);
gluTessCallback(tess, GLU_TESS_END, glEnd);
gluTessBeginPolygon(tess, NULL);
gluTessBeginContour(tess);
for (int i = 0; i < G_N_ELEMENTS(verts); i++)
gluTessVertex(tess, verts[i], verts[i]);
gluTessEndContour(tess);
gluTessEndPolygon(tess);
gluDeleteTess(tess);
/* Draw tesselated polygon */
//glColor4f(0.0, 0.0, 0.5, 1.0);
//glBegin(GL_POLYGON);
//for (int i = 0; i < G_N_ELEMENTS(verts); i++)
// glVertex3dv(verts[i]);
//glEnd();
/* Draw outline */
glColor4f(0.8, 0.8, 0.8, 1.0);
glBegin(GL_LINE_LOOP);
for (int i = 0; i < G_N_ELEMENTS(verts); i++)
glVertex3dv(verts[i]);
glEnd();
/* Flush */
GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
return FALSE;
}
void
extrudeSolidFromPolygon(GLfloat data[][2], unsigned int dataSize,
GLdouble thickness, GLuint side, GLuint edge, GLuint whole)
{
static GLUtriangulatorObj *tobj = NULL;
GLdouble vertex[3], dx, dy, len;
int i;
int count = dataSize / (int) (2 * sizeof(GLfloat));
if (tobj == NULL) {
tobj = gluNewTess(); /* create and initialize a GLU
polygon tesselation object */
gluTessCallback(tobj, GLU_BEGIN, glBegin);
gluTessCallback(tobj, GLU_VERTEX, glVertex2fv); /* semi-tricky */
gluTessCallback(tobj, GLU_END, glEnd);
}
glNewList(side, GL_COMPILE);
glShadeModel(GL_SMOOTH); /* smooth minimizes seeing
tessellation */
gluBeginPolygon(tobj);
for (i = 0; i < count; i++) {
vertex[0] = data[i][0];
vertex[1] = data[i][1];
vertex[2] = 0;
gluTessVertex(tobj, vertex, data[i]);
}
gluEndPolygon(tobj);
glEndList();
glNewList(edge, GL_COMPILE);
glShadeModel(GL_FLAT); /* flat shade keeps angular hands
from being "smoothed" */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= count; i++) {
/* mod function handles closing the edge */
glVertex3f(data[i % count][0], data[i % count][1], 0.0);
glVertex3f(data[i % count][0], data[i % count][1], thickness);
/* Calculate a unit normal by dividing by Euclidean
distance. We * could be lazy and use
glEnable(GL_NORMALIZE) so we could pass in * arbitrary
normals for a very slight performance hit. */
dx = data[(i + 1) % count][1] - data[i % count][1];
dy = data[i % count][0] - data[(i + 1) % count][0];
len = sqrt(dx * dx + dy * dy);
glNormal3f(dx / len, dy / len, 0.0);
}
glEnd();
glEndList();
glNewList(whole, GL_COMPILE);
glFrontFace(GL_CW);
glCallList(edge);
glNormal3f(0.0, 0.0, -1.0); /* constant normal for side */
glCallList(side);
glPushMatrix();
glTranslatef(0.0, 0.0, thickness);
glFrontFace(GL_CCW);
glNormal3f(0.0, 0.0, 1.0); /* opposite normal for other side */
glCallList(side);
glPopMatrix();
glEndList();
}
void DebugHooks::drawFaceLoop(const std::vector<const carve::geom3d::Vector *> &face_loop,
const carve::geom3d::Vector &normal,
float r, float g, float b, float a,
bool lit) {
if (lit) glEnable(GL_LIGHTING); else glDisable(GL_LIGHTING);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
GLUtesselator *tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, (GLUTessCallback)glBegin);
gluTessCallback(tess, GLU_TESS_VERTEX, (GLUTessCallback)glVertex3dv);
gluTessCallback(tess, GLU_TESS_END, (GLUTessCallback)glEnd);
glNormal3dv(normal.v);
glColor4f(r, g, b, a);
gluTessBeginPolygon(tess, (void *)NULL);
gluTessBeginContour(tess);
std::vector<carve::geom3d::Vector> v;
v.resize(face_loop.size());
for (size_t i = 0, l = face_loop.size(); i != l; ++i) {
v[i] = g_scale * (*face_loop[i] + g_translation);
gluTessVertex(tess, (GLdouble *)v[i].v, (GLvoid *)v[i].v);
}
gluTessEndContour(tess);
gluTessEndPolygon(tess);
gluDeleteTess(tess);
glEnable(GL_LIGHTING);
}
void LLRegion::Put( const LLRegion& region, int winding_rule, bool reverse)
{
work w(*this);
gluTessCallback( w.tobj, GLU_TESS_VERTEX_DATA, (_GLUfuncptr) &LLvertexCallback );
gluTessCallback( w.tobj, GLU_TESS_BEGIN, (_GLUfuncptr) &LLbeginCallback );
gluTessCallback( w.tobj, GLU_TESS_COMBINE_DATA, (_GLUfuncptr) &LLcombineCallback );
gluTessCallback( w.tobj, GLU_TESS_END_DATA, (_GLUfuncptr) &LLendCallback );
gluTessCallback( w.tobj, GLU_TESS_ERROR, (_GLUfuncptr) &LLerrorCallback );
gluTessProperty(w.tobj, GLU_TESS_WINDING_RULE, winding_rule);
gluTessProperty(w.tobj, GLU_TESS_BOUNDARY_ONLY, GL_TRUE);
// gluTessProperty(w.tobj, GLU_TESS_TOLERANCE, 1e-5);
gluTessNormal( w.tobj, 0, 0, 1);
gluTessBeginPolygon(w.tobj, &w);
PutContours(w, *this);
PutContours(w, region, reverse);
contours.clear();
gluTessEndPolygon( w.tobj );
Optimize();
m_box.Invalidate();
}
void drawFace(carve::poly::Face<3> *face, cRGBA fc, bool offset) {
//glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
GLUtesselator *tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (GLUTessCallback)_faceBegin);
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLUTessCallback)_faceVertex);
gluTessCallback(tess, GLU_TESS_END_DATA, (GLUTessCallback)_faceEnd);
gluTessBeginPolygon(tess, (void *)face);
gluTessBeginContour(tess);
carve::geom3d::Vector g_translation;
double g_scale = 1.0;
std::vector<std::pair<carve::geom3d::Vector, cRGBA> > v;
v.resize(face->nVertices());
for (size_t i = 0, l = face->nVertices(); i != l; ++i) {
v[i] = std::make_pair(g_scale * (face->vertex(i)->v + g_translation), fc);
gluTessVertex(tess, (GLdouble *)v[i].first.v, (GLvoid *)&v[i]);
}
gluTessEndContour(tess);
gluTessEndPolygon(tess);
gluDeleteTess(tess);
}
eBool eTriangulator::triangulate()
{
m_triIndices.clear();
m_triIndices.reserve(m_totalVtxCount*3);
GLUtesselator *tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_EDGE_FLAG_DATA, (void (eCALLBACK *)())_edgeFlagCallback);
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (void (eCALLBACK *)())_vertexCallback);
gluTessCallback(tess, GLU_TESS_ERROR_DATA, (void (eCALLBACK *)())_errorCallback);
gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (void (eCALLBACK *)())_combineCallback);
gluTessBeginPolygon(tess, this);
for (eU32 i=0, vtxNum=0; i<m_contours.size(); i++)
{
const eArray<eVector3> &contour = *m_contours[i];
if(contour.isEmpty())
continue;
gluTessBeginContour(tess);
{
for (eU32 j=0; j<contour.size(); j++)
{
eF64 coords[] = {contour[j].x, contour[j].y, contour[j].z};
gluTessVertex(tess, coords, (ePtr)vtxNum);
vtxNum++;
}
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
eASSERT(m_triIndices.size()%3 == 0);
return eTRUE;
}
XMGPolygonImpl::XMGPolygonImpl ( GLuint num_shape, const GLuint* arr_num_vertex, XMGBool* has_face )
{
GLuint idx_tess;
GLuint idx_shape;
m_num_shape = num_shape;
for ( idx_tess = 0; idx_tess < 2; idx_tess++ )
{
m_tess[ idx_tess ] = 0;
m_data[ idx_tess ] = 0;
if ( has_face[ idx_tess ] == XMG_TRUE )
{
XMGAssert ( m_data[ idx_tess ] = (XMGTess **) kdMalloc ( sizeof ( XMGTess * ) * num_shape ) );
for ( idx_shape = 0; idx_shape < num_shape; idx_shape++ )
{
XMGAssert ( m_data[ idx_tess ][ idx_shape ] = new XMGTess ( arr_num_vertex[ idx_shape ] ) );
}
XMGAssert ( m_tess[ idx_tess ] = gluNewTess ( ) );
gluTessCallback ( m_tess[ idx_tess ], GLU_TESS_ERROR , (_GLUfuncptr) &callback_tess_error );
gluTessCallback ( m_tess[ idx_tess ], GLU_TESS_BEGIN_DATA , (_GLUfuncptr) &callback_tess_begin );
gluTessCallback ( m_tess[ idx_tess ], GLU_TESS_VERTEX_DATA , (_GLUfuncptr) &callback_tess_vertex );
gluTessCallback ( m_tess[ idx_tess ], GLU_TESS_COMBINE_DATA, (_GLUfuncptr) &callback_tess_combine );
gluTessProperty ( m_tess[ idx_tess ], GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
}
}
}
void
GUIPolygon::performTesselation(SUMOReal lineWidth) const {
if (getFill()) {
// draw the tesselated shape
double* points = new double[myShape.size() * 3];
GLUtesselator* tobj = gluNewTess();
gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid(APIENTRY*)()) &glVertex3dv);
gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid(APIENTRY*)()) &beginCallback);
gluTessCallback(tobj, GLU_TESS_END, (GLvoid(APIENTRY*)()) &endCallback);
//gluTessCallback(tobj, GLU_TESS_ERROR, (GLvoid (APIENTRY*) ()) &errorCallback);
gluTessCallback(tobj, GLU_TESS_COMBINE, (GLvoid(APIENTRY*)()) &combineCallback);
gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
gluTessBeginPolygon(tobj, NULL);
gluTessBeginContour(tobj);
for (size_t i = 0; i != myShape.size(); ++i) {
points[3 * i] = myShape[(int) i].x();
points[3 * i + 1] = myShape[(int) i].y();
points[3 * i + 2] = 0;
gluTessVertex(tobj, points + 3 * i, points + 3 * i);
}
gluTessEndContour(tobj);
gluTessEndPolygon(tobj);
gluDeleteTess(tobj);
delete[] points;
} else {
myLineWidth = lineWidth;
GLHelper::drawLine(myShape);
GLHelper::drawBoxLines(myShape, myLineWidth);
}
//std::cout << "OpenGL says: '" << gluErrorString(glGetError()) << "'\n";
}
MapPainterOpenGL::MapPainterOpenGL(const StyleConfigRef& styleConfig)
: MapPainter(styleConfig,
new CoordBufferImpl<Vertex3D>()),
coordBuffer((CoordBufferImpl<Vertex3D>*)transBuffer.buffer),
tesselator(gluNewTess())
{
gluTessNormal(tesselator,
0,0,1);
gluTessCallback(tesselator,
GLU_TESS_BEGIN,
(GLvoid(CALLBACK *)()) &tessalatorBeginCallback);
gluTessCallback(tesselator,
GLU_TESS_VERTEX,
(GLvoid(CALLBACK *)()) &glVertex3dv);
gluTessCallback(tesselator,
GLU_TESS_END,
(GLvoid(CALLBACK *)()) &tessalatorEndCallback);
gluTessCallback(tesselator,
GLU_TESS_ERROR,
(GLvoid(CALLBACK *)()) &tesselatorErrorCallback);
}
void mapdraw()
{
VisiLibity::Point pt1;
//pt1=VisiLibity::Point(160.0f,180.0f);
pt1=guest1.pos;
pt1.snap_to_boundary_of(mapEnv);
pt1.snap_to_vertices_of(mapEnv);
visiPoly=VisiLibity::Visibility_Polygon(pt1,mapEnv,0.00001);
Polygon_2 CGALvp;
for (int j=0;j<visiPoly.n();j++){
CGALvp.push_back(Point_2(visiPoly[j].x(),visiPoly[j].y()));
};
// CGAL::difference(mapEnvOB,holeCGAL,std::back_inserter(mapEnvOB));
Polygon_2 visRange=ngon(20,150.0);
Pwh_list_2 intR;
CGAL::intersection(CGALvp,visRange,std::back_inserter(intR));
visiBounded=intR.front();
tess = gluNewTess();
gluTessCallback (tess, GLU_TESS_BEGIN, (GLvoid (CALLBACK *)())tcbBegin);
gluTessCallback (tess, GLU_TESS_VERTEX, (GLvoid (CALLBACK *)())tcbVertex);
gluTessCallback (tess, GLU_TESS_END, (GLvoid (CALLBACK *)())tcbEnd);
};
/* Generate an extruded, capped part from a 2-D polyline. */
static void
ExtrudePart(int n, GLfloat v[][2], float depth)
{
static GLUtriangulatorObj *tobj = NULL;
int i;
float z0 = 0.5 * depth;
float z1 = -0.5 * depth;
GLdouble vertex[3];
if (tobj == NULL) {
tobj = gluNewTess(); /* create and initialize a GLU polygon * *
tesselation object */
gluTessCallback(tobj, GLU_BEGIN, glBegin);
gluTessCallback(tobj, GLU_VERTEX, glVertex2fv); /* semi-tricky */
gluTessCallback(tobj, GLU_END, glEnd);
}
/* +Z face */
glPushMatrix();
glTranslatef(0.0, 0.0, z0);
glNormal3f(0.0, 0.0, 1.0);
gluBeginPolygon(tobj);
for (i = 0; i < n; i++) {
vertex[0] = v[i][0];
vertex[1] = v[i][1];
vertex[2] = 0.0;
gluTessVertex(tobj, vertex, v[i]);
}
gluEndPolygon(tobj);
glPopMatrix();
/* -Z face */
glFrontFace(GL_CW);
glPushMatrix();
glTranslatef(0.0, 0.0, z1);
glNormal3f(0.0, 0.0, -1.0);
gluBeginPolygon(tobj);
for (i = 0; i < n; i++) {
vertex[0] = v[i][0];
vertex[1] = v[i][1];
vertex[2] = z1;
gluTessVertex(tobj, vertex, v[i]);
}
gluEndPolygon(tobj);
glPopMatrix();
glFrontFace(GL_CCW);
/* edge polygons */
glBegin(GL_TRIANGLE_STRIP);
for (i = 0; i <= n; i++) {
float x = v[i % n][0];
float y = v[i % n][1];
float dx = v[(i + 1) % n][0] - x;
float dy = v[(i + 1) % n][1] - y;
glVertex3f(x, y, z0);
glVertex3f(x, y, z1);
glNormal3f(dy, -dx, 0.0);
}
glEnd();
}
VRML_LAYER::VRML_LAYER()
{
fix = false;
Fault = false;
idx = 0;
ord = 0;
glcmd = 0;
pholes = NULL;
maxdev = 0.02;
tess = gluNewTess();
if( !tess )
return;
// set up the tesselator callbacks
gluTessCallback( tess, GLU_TESS_BEGIN_DATA, GLCALLBACK( vrml_tess_begin ) );
gluTessCallback( tess, GLU_TESS_VERTEX_DATA, GLCALLBACK( vrml_tess_vertex ) );
gluTessCallback( tess, GLU_TESS_END_DATA, GLCALLBACK( vrml_tess_end ) );
gluTessCallback( tess, GLU_TESS_ERROR_DATA, GLCALLBACK( vrml_tess_err ) );
gluTessCallback( tess, GLU_TESS_COMBINE_DATA, GLCALLBACK( vrml_tess_combine ) );
gluTessProperty( tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
gluTessNormal( tess, 0, 0, 1 );
}
int ProtoTessellator::init() {
// Create a new tessellation object
tesselator = gluNewTess();
if (!tesselator) return 0;
// Set callback functions
gluTessCallback(tesselator, GLU_TESS_VERTEX, (GLvoid(__stdcall *)()) &vertexCallback);
gluTessCallback(tesselator, GLU_TESS_BEGIN, (GLvoid(__stdcall *)()) &testMeBegin);
gluTessCallback(tesselator, GLU_TESS_END, (GLvoid(__stdcall *)()) &testMeEnd);
gluTessCallback(tesselator, GLU_TESS_COMBINE, (GLvoid(__stdcall *)()) &combineCallback);
gluTessCallback(tesselator, GLU_TESS_ERROR, (GLvoid(__stdcall *)()) &tesellationError);
//gluTessCallback(tess, GLU_TESS_BEGIN, (void (CALLBACK *)())tessBeginCB);
//gluTessCallback(tess, GLU_TESS_END, (void (CALLBACK *)())tessEndCB);
//gluTessCallback(tess, GLU_TESS_ERROR, (void (CALLBACK *)())tessErrorCB);
//gluTessCallback(tess, GLU_TESS_VERTEX, (void (CALLBACK *)())tessVertexCB);
//gluTessCallback(tesselator, GLU_TESS_BEGIN, (GLvoid(CALLBACK *)()) ProtoTessellator::begin);
//gluTessCallback(tesselator, GLU_TESS_EDGE_FLAG, (GLvoid(CALLBACK *)()) ProtoTessellator::edgeFlag);
//gluTessCallback(tesselator, GLU_TESS_END, (GLvoid(CALLBACK *)()) ProtoTessellator::end);
//gluTessCallback(tesselator, GLU_TESS_VERTEX_DATA, (GLvoid(CALLBACK *)()) ProtoTessellator::vertexData);
//gluTessCallback(tesselator, GLU_TESS_COMBINE_DATA, (GLvoid(CALLBACK *)()) ProtoTessellator::combineData);
//gluTessNormal(tesselator, 0.0, 0.0, 1.0);
return 1;
}
void drawTexturedPolyhedron(carve::mesh::MeshSet<3> *poly,
carve::interpolate::FaceVertexAttr<tex_t> &fv_tex,
carve::interpolate::FaceAttr<GLuint> &f_tex_num) {
glEnable(GL_TEXTURE_2D);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
GLUtesselator *tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, (GLUTessCallback)glBegin);
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (GLUTessCallback)tess_vertex);
gluTessCallback(tess, GLU_TESS_END, (GLUTessCallback)glEnd);
for (carve::mesh::MeshSet<3>::face_iter i = poly->faceBegin(); i != poly->faceEnd(); ++i) {
carve::mesh::MeshSet<3>::face_t *f = *i;
std::vector<vt_t> vc(f->nVertices());
bool textured = true;
for (carve::mesh::MeshSet<3>::face_t::edge_iter_t e = f->begin(); e != f->end(); ++e) {
vc[e.idx()].x = g_scale * (e->vert->v.x + g_translation.x);
vc[e.idx()].y = g_scale * (e->vert->v.y + g_translation.y);
vc[e.idx()].z = g_scale * (e->vert->v.z + g_translation.z);
if (fv_tex.hasAttribute(f, e.idx())) {
tex_t t = fv_tex.getAttribute(f, e.idx());
vc[e.idx()].u = t.u;
vc[e.idx()].v = t.v;
} else {
textured = false;
}
}
if (textured) {
GLuint tex_num = f_tex_num.getAttribute(f, 0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex_num);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
} else {
glColor4f(0.5f, 0.6f, 0.7f, 1.0f);
}
glNormal3dv(f->plane.N.v);
gluTessBeginPolygon(tess, (void *)&textured);
gluTessBeginContour(tess);
for (size_t j = 0; j != vc.size(); ++j) {
gluTessVertex(tess, (GLdouble *)&vc[j], (GLvoid *)&vc[j]);
}
gluTessEndContour(tess);
gluTessEndPolygon(tess);
}
gluDeleteTess(tess);
glDisable(GL_TEXTURE_2D);
}
bool Opengl2dPainter::initGL()
{
glClearColor(0, 0, 0, 1);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glShadeModel(GL_SMOOTH);
_pPimpl->pTesslation = gluNewTess();
gluTessCallback(_pPimpl->pTesslation, GLU_TESS_BEGIN,
(void (__stdcall *)(void))CustomTessBegin); //<1>
gluTessCallback(_pPimpl->pTesslation, GLU_TESS_VERTEX,
(void (__stdcall *)(void))CustomTessVertex); //<2>
gluTessCallback(_pPimpl->pTesslation, GLU_TESS_END,
(void (__stdcall *)(void))CustomTessEnd); //<3>
gluTessCallback(_pPimpl->pTesslation, GLU_TESS_ERROR,
(void (__stdcall *)(void))CustomTessError); //<4>
return true;
}
/*
* initialize
*/
void TessellatePolygon::initialize(void) {
tessellationObject = gluNewTess();
gluTessCallback(tessellationObject, GLU_TESS_VERTEX, (GLvoid (*) ()) &vertexCallback);
gluTessCallback(tessellationObject, GLU_TESS_BEGIN, (GLvoid(*)()) &glBegin);
gluTessCallback(tessellationObject, GLU_TESS_END, (GLvoid(*)()) &glEnd);
gluTessCallback(tessellationObject, GLU_TESS_COMBINE, (GLvoid(*)()) &combineCallback);
} // end initialize()
void g::render_level::compile_displaylist(const level& lev)
{
// clear
for(vbos_t::iterator it = vbos.begin(); it != vbos.end(); it++)
glDeleteBuffers(1, &it->first.first);
vbos.clear();
sizes.clear();
// set vertex data
typedef std::vector<std::vector<GLdouble*> > vertices_t;
vertices_t vertices;
for(level::polygon_container::const_iterator it = lev.polygons.begin(); it != lev.polygons.end(); it++)
{
vertices.push_back(std::vector<GLdouble*>());
for(level::vertex_container::const_iterator jt = it->begin(); jt != it->end(); jt++)
{
GLdouble* vertex = new GLdouble[3];
vertex[0] = jt->x();
vertex[1] = jt->y();
vertex[2] = 0.0;
vertices.back().push_back(vertex);
}
}
// set glu tesselator
typedef void (CALLBACK* func)();
GLUtesselator* tess = gluNewTess();
BOOST_ASSERT(tess != NULL);
gluTessCallback(tess, GLU_TESS_BEGIN, (func)tessbegin);
gluTessCallback(tess, GLU_TESS_END, (func)tessend);
gluTessCallback(tess, GLU_TESS_ERROR, (func)tesserror);
gluTessCallback(tess, GLU_TESS_VERTEX, (func)tessvertex);
// add to vbo
for(vertices_t::iterator it = vertices.begin(); it != vertices.end(); it++)
{
gluTessBeginPolygon(tess, NULL);
gluTessBeginContour(tess);
for(vertices_t::value_type::iterator jt = it->begin(); jt != it->end(); jt++)
gluTessVertex(tess, *jt, *jt);
gluTessEndContour(tess);
gluTessEndPolygon(tess);
}
for(vbos_t::iterator it = vbos.begin(); it != vbos.end(); it++)
{
glBindBuffer(GL_ARRAY_BUFFER, it->first.first);
glBufferData(GL_ARRAY_BUFFER, it->second.size() * sizeof(GLdouble), it->second.data(), GL_STATIC_DRAW);
}
// cleanup
gluDeleteTess(tess);
for(vertices_t::iterator it = vertices.begin(); it != vertices.end(); it++)
for(vertices_t::value_type::iterator jt = it->begin(); jt != it->end(); jt++)
delete [] *jt;
for(vbos_t::iterator it = vbos.begin(); it != vbos.end(); it++)
{
sizes.push_back(it->second.size());
it->second.clear();
}
}
void
hidgl_fill_polygon (int n_coords, Coord *x, Coord *y)
{
int i;
GLUtesselator *tobj;
GLdouble *vertices;
assert (n_coords > 0);
vertices = malloc (sizeof(GLdouble) * n_coords * 3);
tobj = gluNewTess ();
gluTessCallback(tobj, GLU_TESS_BEGIN, (_GLUfuncptr)myBegin);
gluTessCallback(tobj, GLU_TESS_VERTEX, (_GLUfuncptr)myVertex);
gluTessCallback(tobj, GLU_TESS_COMBINE, (_GLUfuncptr)myCombine);
gluTessCallback(tobj, GLU_TESS_ERROR, (_GLUfuncptr)myError);
gluTessBeginPolygon (tobj, NULL);
gluTessBeginContour (tobj);
for (i = 0; i < n_coords; i++)
{
vertices [0 + i * 3] = x[i];
vertices [1 + i * 3] = y[i];
vertices [2 + i * 3] = 0.;
gluTessVertex (tobj, &vertices [i * 3], &vertices [i * 3]);
}
gluTessEndContour (tobj);
gluTessEndPolygon (tobj);
gluDeleteTess (tobj);
myFreeCombined ();
free (vertices);
}
void
GLHelper::drawFilledPolyTesselated(const PositionVector& v, bool close) {
if (v.size() == 0) {
return;
}
GLUtesselator* tobj = gluNewTess();
gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid(APIENTRY*)()) &glVertex3dv);
gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid(APIENTRY*)()) &glBegin);
gluTessCallback(tobj, GLU_TESS_END, (GLvoid(APIENTRY*)()) &glEnd);
gluTessCallback(tobj, GLU_TESS_COMBINE, (GLvoid(APIENTRY*)()) &combCallback);
gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
gluTessBeginPolygon(tobj, nullptr);
gluTessBeginContour(tobj);
double* points = new double[(v.size() + int(close)) * 3];
for (int i = 0; i != (int)v.size(); ++i) {
points[3 * i] = v[i].x();
points[3 * i + 1] = v[i].y();
points[3 * i + 2] = 0;
gluTessVertex(tobj, points + 3 * i, points + 3 * i);
}
if (close) {
const int i = (int)v.size();
points[3 * i] = v[0].x();
points[3 * i + 1] = v[0].y();
points[3 * i + 2] = 0;
gluTessVertex(tobj, points + 3 * i, points + 3 * i);
}
gluTessEndContour(tobj);
gluTessEndPolygon(tobj);
gluDeleteTess(tobj);
delete[] points;
}
void
GLInfo::setTessPolygonContext()
{
setTessContext();
typedef void (GLAPIENTRYP fn_type)(void);
gluTessCallback(gluTriangulator, GLU_TESS_VERTEX, reinterpret_cast<fn_type>(tessVertexPolygon));
gluTessCallback(gluTriangulator, GLU_TESS_COMBINE, reinterpret_cast<fn_type>(tessVertexCombine));
}
void DrawPolygon(clipper::Polygons &pgs)
{
glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
GLUtesselator* tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, (void (CALLBACK*)())&BeginCallback);
gluTessCallback(tess, GLU_TESS_VERTEX, (void (CALLBACK*)())&VertexCallback);
gluTessCallback(tess, GLU_TESS_END, (void (CALLBACK*)())&EndCallback);
gluTessCallback(tess, GLU_TESS_COMBINE, (void (CALLBACK*)())&CombineCallback);
gluTessCallback(tess, GLU_TESS_ERROR, (void (CALLBACK*)())&ErrorCallback);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO);
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);
gluTessBeginPolygon(tess, NULL);
for (clipper::Polygons::size_type i = 0; i < pgs.size(); ++i)
{
gluTessBeginContour(tess);
for (clipper::Polygon::size_type j = 0; j < pgs[i].size(); ++j)
{
GLdouble *vert = new GLdouble[3];
vert[0] = (GLdouble)pgs[i][j].X;
vert[1] = (GLdouble)pgs[i][j].Y;
vert[2] = 0;
AddToCleanup(vert);
gluTessVertex(tess, vert, vert);
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
DoCleanup();
glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
glLineWidth(1.2f);
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_TRUE); //GL_FALSE
gluTessBeginPolygon(tess, NULL);
for (clipper::Polygons::size_type i = 0; i < pgs.size(); ++i)
{
gluTessBeginContour(tess);
for (clipper::Polygon::size_type j = 0; j < pgs[i].size(); ++j)
{
GLdouble *vert = new GLdouble[3];
vert[0] = (GLdouble)pgs[i][j].X;
vert[1] = (GLdouble)pgs[i][j].Y;
vert[2] = 0;
AddToCleanup(vert);
gluTessVertex(tess, vert, vert);
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
//final cleanup ...
gluDeleteTess(tess);
DoCleanup();
}
static void
draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc,
struct point *p, int count)
{
int i;
if ((gr->parent && !gr->parent->overlay_enabled)
|| (gr->parent && gr->parent->overlay_enabled
&& !gr->overlay_enabled)) {
return;
}
#if USE_OPENGLES
set_color(gr, gc);
draw_array(gr, p, count, GL_LINE_STRIP);
#else
graphics_priv_root->dirty = 1;
GLUtesselator *tess = gluNewTess(); // create a tessellator
if (!tess)
return; // failed to create tessellation object, return 0
GLdouble quad1[count][3];
for (i = 0; i < count; i++) {
quad1[i][0] = (GLdouble) (p[i].x);
quad1[i][1] = (GLdouble) (p[i].y);
quad1[i][2] = 0;
}
// register callback functions
gluTessCallback(tess, GLU_TESS_BEGIN, (void (APIENTRY *)(void)) tessBeginCB);
gluTessCallback(tess, GLU_TESS_END, (void (APIENTRY *)(void)) tessEndCB);
// gluTessCallback(tess, GLU_TESS_ERROR, (void (*)(void))tessErrorCB);
gluTessCallback(tess, GLU_TESS_VERTEX, (void (APIENTRY *)(void)) tessVertexCB);
gluTessCallback(tess, GLU_TESS_COMBINE, (void (APIENTRY *)(void)) tessCombineCB);
// tessellate and compile a concave quad into display list
// gluTessVertex() takes 3 params: tess object, pointer to vertex coords,
// and pointer to vertex data to be passed to vertex callback.
// The second param is used only to perform tessellation, and the third
// param is the actual vertex data to draw. It is usually same as the second
// param, but It can be more than vertex coord, for example, color, normal
// and UV coords which are needed for actual drawing.
// Here, we are looking at only vertex coods, so the 2nd and 3rd params are
// pointing same address.
glColor4f(gc->fr, gc->fg, gc->fb, gc->fa);
gluTessBeginPolygon(tess, 0); // with NULL data
gluTessBeginContour(tess);
for (i = 0; i < count; i++) {
gluTessVertex(tess, quad1[i], quad1[i]);
}
gluTessEndContour(tess);
gluTessEndPolygon(tess);
gluDeleteTess(tess); // delete after tessellation
#endif
}
static GLUtesselator *
gst_opengl_gluNewTess (void)
{
GLUtesselator *tess = gluNewTess ();
gluTessCallback(tess, GLU_TESS_BEGIN, glBegin);
gluTessCallback(tess, GLU_TESS_VERTEX, (GLUfuncptr) gst_opengl_glVertexv);
gluTessCallback(tess, GLU_TESS_END, glEnd);
return tess;
}
void ocpnDC::DrawPolygonTessellated( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
if( dc )
dc->DrawPolygon( n, points, xoffset, yoffset );
#ifdef ocpnUSE_GL
else {
# ifndef ocpnUSE_GLES // tessalator in glues is broken
if( n < 5 )
# endif
{
DrawPolygon( n, points, xoffset, yoffset );
return;
}
glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT | GL_HINT_BIT | GL_POLYGON_BIT ); //Save state
SetGLAttrs( false );
static GLUtesselator *tobj = NULL;
if( ! tobj ) tobj = gluNewTess();
gluTessCallback( tobj, GLU_TESS_VERTEX, (_GLUfuncptr) &ocpnDCvertexCallback );
gluTessCallback( tobj, GLU_TESS_BEGIN, (_GLUfuncptr) &ocpnDCbeginCallback );
gluTessCallback( tobj, GLU_TESS_END, (_GLUfuncptr) &ocpnDCendCallback );
gluTessCallback( tobj, GLU_TESS_COMBINE, (_GLUfuncptr) &ocpnDCcombineCallback );
gluTessCallback( tobj, GLU_TESS_ERROR, (_GLUfuncptr) &ocpnDCerrorCallback );
gluTessNormal( tobj, 0, 0, 1);
gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO );
if( ConfigureBrush() ) {
gluTessBeginPolygon( tobj, NULL );
gluTessBeginContour( tobj );
for( int i = 0; i < n; i++ ) {
GLvertex* vertex = new GLvertex();
gTesselatorVertices.Add( vertex );
vertex->info.x = (GLdouble) points[i].x;
vertex->info.y = (GLdouble) points[i].y;
vertex->info.z = (GLdouble) 0.0;
vertex->info.r = (GLdouble) 0.0;
vertex->info.g = (GLdouble) 0.0;
vertex->info.b = (GLdouble) 0.0;
gluTessVertex( tobj, (GLdouble*)vertex, (GLdouble*)vertex );
}
gluTessEndContour( tobj );
gluTessEndPolygon( tobj );
}
glPopAttrib();
for( unsigned int i=0; i<gTesselatorVertices.Count(); i++ )
delete (GLvertex*)gTesselatorVertices.Item(i);
gTesselatorVertices.Clear();
}
#endif
}
void Slice::drawPolygon(Polygons &pgs, int layer){
glColor4f(0.0f, 1.0f, 0.0f, 0.25f);
GLUtesselator* tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, (GLvoid (__stdcall *) ())&BeginCallback);
gluTessCallback(tess, GLU_TESS_VERTEX, (GLvoid (__stdcall *) ())&VertexCallback);
gluTessCallback(tess, GLU_TESS_END, (GLvoid (__stdcall *) ())&EndCallback);
gluTessCallback(tess, GLU_TESS_COMBINE, (GLvoid (__stdcall *) ())&CombineCallback);
gluTessCallback(tess, GLU_TESS_ERROR, (GLvoid (__stdcall *) ())&ErrorCallback);
gluTessNormal(tess, 0.0, 0.0, 1.0);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE); //GL_FALSE
gluTessBeginPolygon(tess, NULL);
glPushMatrix();
glTranslated(0.0,0.0,this->layerHeight*layer);
for (Polygons::size_type i = 0; i < pgs.size(); ++i)
{
gluTessBeginContour(tess);
for (ClipperLib::Polygon::size_type j = 0; j < pgs[i].size(); ++j)
{
GLdouble *vert =
NewVector((GLdouble)pgs[i][j].X/1000, (GLdouble)pgs[i][j].Y/1000);
gluTessVertex(tess, vert, vert);
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
ClearVectors();
glColor4f(0.0f, 0.6f, 1.0f, 0.5f);
glLineWidth(1.8f);
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_TRUE);
for (Polygons::size_type i = 0; i < pgs.size(); ++i)
{
gluTessBeginPolygon(tess, NULL);
gluTessBeginContour(tess);
for (ClipperLib::Polygon::size_type j = 0; j < pgs[i].size(); ++j)
{
GLdouble *vert =
NewVector((GLdouble)pgs[i][j].X/1000, (GLdouble)pgs[i][j].Y/1000);
gluTessVertex(tess, vert, vert);
}
glColor4f(0.0f, 0.0f, 0.8f, 0.5f);
gluTessEndContour(tess);
gluTessEndPolygon(tess);
}
//final cleanup ...
gluDeleteTess(tess);
ClearVectors();
glPopMatrix();
}
GLShapeRenderer::GLShapeRenderer() {
tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN_DATA, (_GLUfuncptr) beginCallback);
gluTessCallback(tess, GLU_TESS_ERROR, (_GLUfuncptr) errorCallback);
gluTessCallback(tess, GLU_TESS_END_DATA, (_GLUfuncptr) endCallback);
gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (_GLUfuncptr) combineDataCallback);
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, (_GLUfuncptr) vertexCallback);
}
void init_tess()
{
tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_VERTEX, (GLUfuncptr) egl_ogla_vertex);
gluTessCallback(tess, GLU_TESS_EDGE_FLAG, (GLUfuncptr) egl_ogla_edge_flag);
gluTessCallback(tess, GLU_TESS_COMBINE, (GLUfuncptr) egl_ogla_combine);
gluTessCallback(tess, GLU_TESS_ERROR, (GLUfuncptr) egl_ogla_error);
}
void init(void)
{
GLUtesselator *tobj;
GLdouble rect[4][3] = { { 50.0, 50.0, 0.0},
{200.0, 50.0, 0.0},
{200.0, 200.0, 0.0},
{ 50.0, 200.0, 0.0} };
GLdouble tri[3][3] = { { 75.0, 75.0, 0.0},
{125.0, 175.0, 0.0},
{175.0, 75.0, 0.0} };
GLdouble star[5][6] = { {250.0, 50.0, 0.0, 1.0, 0.0, 1.0},
{325.0, 200.0, 0.0, 1.0, 1.0, 0.0},
{400.0, 50.0, 0.0, 0.0, 1.0, 1.0},
{250.0, 150.0, 0.0, 1.0, 0.0, 0.0},
{400.0, 150.0, 0.0, 0.0, 1.0, 0.0} };
glClearColor(0.0, 0.0, 0.0, 0.0);
startList = glGenLists(2);
tobj = gluNewTess();
gluTessCallback(tobj, GLU_TESS_VERTEX, glVertex3dv);
gluTessCallback(tobj, GLU_TESS_BEGIN, beginCallback);
gluTessCallback(tobj, GLU_TESS_END, endCallback);
gluTessCallback(tobj, GLU_TESS_ERROR, errorCallback);
// Rectangle with a triangular hole inside.
glNewList(startList, GL_COMPILE);
glShadeModel(GL_FLAT);
gluTessBeginPolygon(tobj, NULL);
gluTessBeginContour(tobj);
gluTessVertex(tobj, rect[0], rect[0]);
gluTessVertex(tobj, rect[1], rect[1]);
gluTessVertex(tobj, rect[2], rect[2]);
gluTessVertex(tobj, rect[3], rect[3]);
gluTessEndContour(tobj);
gluTessBeginContour(tobj);
gluTessVertex(tobj, tri[0], tri[0]);
gluTessVertex(tobj, tri[1], tri[1]);
gluTessVertex(tobj, tri[2], tri[2]);
gluTessEndContour(tobj);
gluTessEndPolygon(tobj);
glEndList();
gluTessCallback(tobj, GLU_TESS_VERTEX, vertexCallback);
gluTessCallback(tobj, GLU_TESS_BEGIN, beginCallback);
gluTessCallback(tobj, GLU_TESS_END, endCallback);
gluTessCallback(tobj, GLU_TESS_ERROR, errorCallback);
gluTessCallback(tobj, GLU_TESS_COMBINE, combineCallback);
// Smooth shaded, self-intersecting star.
glNewList(startList + 1, GL_COMPILE);
glShadeModel(GL_SMOOTH);
gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE);
gluTessBeginPolygon(tobj, NULL);
gluTessBeginContour(tobj);
gluTessVertex(tobj, star[0], star[0]);
gluTessVertex(tobj, star[1], star[1]);
gluTessVertex(tobj, star[2], star[2]);
gluTessVertex(tobj, star[3], star[3]);
gluTessVertex(tobj, star[4], star[4]);
gluTessEndContour(tobj);
gluTessEndPolygon(tobj);
glEndList();
gluDeleteTess(tobj);
}
static GLUtesselator* Init()
{
// Create a new tessellation object
GLUtesselator* tobj = gluNewTess();
// Set callback functions
gluTessCallback(tobj, GLU_TESS_VERTEX, &vertexCallback);
gluTessCallback(tobj, GLU_TESS_BEGIN, &glBegin);
gluTessCallback(tobj, GLU_TESS_END, &glEnd);
gluTessCallback(tobj, GLU_TESS_COMBINE,&combineCallback);
return tobj;
}
