OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reverted to old tessellator

Browse Source
This commit is contained in:
Brian Paul
2000-07-11 14:11:58 +00:00
parent f88602394d
commit c4266ac71e
1 changed files with 252 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files

618
progs/demos/tessdemo.c
View File

@@ -1,433 +1,331 @@
/* $Id: tessdemo.c,v 1.7 2000/06/27 17:04:43 brianp Exp $ */ /* $Id: tessdemo.c,v 1.8 2000/07/11 14:11:58 brianp Exp $ */
/* /*
* A demo of the GLU polygon tesselation functions written by Bogdan Sikorski. * A demo of the GLU polygon tesselation functions written by Bogdan Sikorski.
* Updated for GLU 1.3 tessellation by Gareth Hughes <garethh@bell-labs.com>
*/ */
#include <GL/glut.h> #include <GL/glut.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#define MAX_POINTS 256 #define MAX_POINTS 200
#define MAX_CONTOURS 32 #define MAX_CONTOURS 50
#define MAX_TRIANGLES 256
#ifndef GLCALLBACK static int menu;
#ifdef CALLBACK typedef enum
#define GLCALLBACK CALLBACK { QUIT, TESSELATE, CLEAR }
#else menu_entries;
#define GLCALLBACK
#endif
#endif
typedef enum{ QUIT, TESSELATE, CLEAR } menu_entries; typedef enum
typedef enum{ DEFINE, TESSELATED } mode_type; { DEFINE, TESSELATED }
mode_type;
static GLsizei width, height; struct
static GLuint contour_cnt;
static GLuint triangle_cnt;
static mode_type mode;
static int menu;
static GLuint list_start;
static GLfloat edge_color[3];
static struct
{ {
GLfloat p[MAX_POINTS][2]; GLint p[MAX_POINTS][2];
GLuint point_cnt; GLuint point_cnt;
} contours[MAX_CONTOURS]; }
contours[MAX_CONTOURS];
static struct static GLuint contour_cnt;
static GLsizei width, height;
static mode_type mode;
struct
{ {
GLsizei no; GLsizei no;
GLfloat p[3][2]; GLfloat color[3];
GLclampf color[3][3]; GLint p[3][2];
} triangles[MAX_TRIANGLES]; GLclampf p_color[3][3];
}
triangle;
static void GLCALLBACK
static void GLCALLBACK error_callback( GLenum err ) my_error(GLenum err)
{ {
int len, i; int len, i;
char const *str; char const *str;
glColor3f( 0.9, 0.9, 0.9 ); glColor3f(0.9, 0.9, 0.9);
glRasterPos2i( 5, 5 ); glRasterPos2i(5, 5);
str = (const char *) gluErrorString(err);
len = strlen(str);
for (i = 0; i < len; i++)
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, str[i]);
}
str = (const char *) gluErrorString( err );
len = strlen( str );
for ( i = 0 ; i < len ; i++ ) { static void GLCALLBACK
glutBitmapCharacter( GLUT_BITMAP_9_BY_15, str[i] ); begin_callback(GLenum mode)
{
triangle.no = 0;
}
static void GLCALLBACK
edge_callback(GLenum flag)
{
if (flag == GL_TRUE) {
triangle.color[0] = 1.0;
triangle.color[1] = 1.0;
triangle.color[2] = 0.5;
}
else {
triangle.color[0] = 1.0;
triangle.color[1] = 0.0;
triangle.color[2] = 0.0;
} }
} }
static void GLCALLBACK begin_callback( GLenum mode )
static void GLCALLBACK
end_callback()
{ {
/* Allow multiple triangles to be output inside the begin/end pair. */ glBegin(GL_LINES);
triangle_cnt = 0; glColor3f(triangle.p_color[0][0], triangle.p_color[0][1],
triangles[triangle_cnt].no = 0; triangle.p_color[0][2]);
} glVertex2i(triangle.p[0][0], triangle.p[0][1]);
glVertex2i(triangle.p[1][0], triangle.p[1][1]);
static void GLCALLBACK edge_callback( GLenum flag ) glColor3f(triangle.p_color[1][0], triangle.p_color[1][1],
{ triangle.p_color[1][2]);
/* Persist the edge flag across triangles. */ glVertex2i(triangle.p[1][0], triangle.p[1][1]);
if ( flag == GL_TRUE ) glVertex2i(triangle.p[2][0], triangle.p[2][1]);
{ glColor3f(triangle.p_color[2][0], triangle.p_color[2][1],
edge_color[0] = 1.0; triangle.p_color[2][2]);
edge_color[1] = 1.0; glVertex2i(triangle.p[2][0], triangle.p[2][1]);
edge_color[2] = 0.5; glVertex2i(triangle.p[0][0], triangle.p[0][1]);
}
else
{
edge_color[0] = 1.0;
edge_color[1] = 0.0;
edge_color[2] = 0.0;
}
}
static void GLCALLBACK end_callback()
{
GLint i;
glBegin( GL_LINES );
/* Output the three edges of each triangle as lines colored
according to their edge flag. */
for ( i = 0 ; i < triangle_cnt ; i++ )
{
glColor3f( triangles[i].color[0][0],
triangles[i].color[0][1],
triangles[i].color[0][2] );
glVertex2f( triangles[i].p[0][0], triangles[i].p[0][1] );
glVertex2f( triangles[i].p[1][0], triangles[i].p[1][1] );
glColor3f( triangles[i].color[1][0],
triangles[i].color[1][1],
triangles[i].color[1][2] );
glVertex2f( triangles[i].p[1][0], triangles[i].p[1][1] );
glVertex2f( triangles[i].p[2][0], triangles[i].p[2][1] );
glColor3f( triangles[i].color[2][0],
triangles[i].color[2][1],
triangles[i].color[2][2] );
glVertex2f( triangles[i].p[2][0], triangles[i].p[2][1] );
glVertex2f( triangles[i].p[0][0], triangles[i].p[0][1] );
}
glEnd(); glEnd();
} }
static void GLCALLBACK vertex_callback( void *data )
static void GLCALLBACK
vertex_callback(void *data)
{ {
GLsizei no; GLsizei no;
GLfloat *p; GLint *p;
p = (GLfloat *) data; p = (GLint *) data;
no = triangles[triangle_cnt].no; no = triangle.no;
triangle.p[no][0] = p[0];
triangles[triangle_cnt].p[no][0] = p[0]; triangle.p[no][1] = p[1];
triangles[triangle_cnt].p[no][1] = p[1]; triangle.p_color[no][0] = triangle.color[0];
triangle.p_color[no][1] = triangle.color[1];
triangles[triangle_cnt].color[no][0] = edge_color[0]; triangle.p_color[no][2] = triangle.color[2];
triangles[triangle_cnt].color[no][1] = edge_color[1]; ++(triangle.no);
triangles[triangle_cnt].color[no][2] = edge_color[2];
/* After every three vertices, initialize the next triangle. */
if ( ++(triangles[triangle_cnt].no) == 3 )
{
triangle_cnt++;
triangles[triangle_cnt].no = 0;
}
}
static void GLCALLBACK combine_callback( GLdouble coords[3],
GLdouble *vertex_data[4],
GLfloat weight[4], void **data )
{
GLfloat *vertex;
vertex = (GLfloat *) malloc( 2 * sizeof(GLfloat) );
vertex[0] = (GLfloat) coords[0];
vertex[1] = (GLfloat) coords[1];
*data = vertex;
} }
static void set_screen_wh( GLsizei w, GLsizei h ) static void
set_screen_wh(GLsizei w, GLsizei h)
{ {
width = w; width = w;
height = h; height = h;
} }
static void tesse( void )
{
GLUtesselator *tobj;
GLdouble data[3];
GLuint i, j, point_cnt;
list_start = glGenLists( 2 ); static void
tesse(void)
{
GLUtriangulatorObj *tobj;
GLdouble data[3];
GLuint i, j, point_cnt;
tobj = gluNewTess(); tobj = gluNewTess();
if (tobj != NULL) {
if ( tobj != NULL ) glClear(GL_COLOR_BUFFER_BIT);
{ glColor3f(0.7, 0.7, 0.0);
gluTessNormal( tobj, 0.0, 0.0, 1.0 ); gluTessCallback(tobj, GLU_BEGIN, glBegin);
gluTessCallback( tobj, GLU_TESS_BEGIN, glBegin ); gluTessCallback(tobj, GLU_END, glEnd);
gluTessCallback( tobj, GLU_TESS_VERTEX, glVertex2fv ); gluTessCallback(tobj, GLU_ERROR, my_error);
gluTessCallback( tobj, GLU_TESS_END, glEnd ); gluTessCallback(tobj, GLU_VERTEX, glVertex2iv);
gluTessCallback( tobj, GLU_TESS_ERROR, error_callback ); gluBeginPolygon(tobj);
gluTessCallback( tobj, GLU_TESS_COMBINE, combine_callback ); for (j = 0; j <= contour_cnt; j++) {
glNewList( list_start, GL_COMPILE );
gluBeginPolygon( tobj );
for ( j = 0 ; j <= contour_cnt ; j++ )
{
point_cnt = contours[j].point_cnt; point_cnt = contours[j].point_cnt;
gluNextContour( tobj, GLU_UNKNOWN ); gluNextContour(tobj, GLU_UNKNOWN);
for (i = 0; i < point_cnt; i++) {
for ( i = 0 ; i < point_cnt ; i++ ) data[0] = (GLdouble) (contours[j].p[i][0]);
{ data[1] = (GLdouble) (contours[j].p[i][1]);
data[0] = (GLdouble)( contours[j].p[i][0] );
data[1] = (GLdouble)( contours[j].p[i][1] );
data[2] = 0.0; data[2] = 0.0;
gluTessVertex( tobj, data, contours[j].p[i] ); gluTessVertex(tobj, data, contours[j].p[i]);
} }
} }
gluEndPolygon(tobj);
gluEndPolygon( tobj ); glLineWidth(2.0);
glEndList(); gluTessCallback(tobj, GLU_BEGIN, begin_callback);
gluTessCallback(tobj, GLU_END, end_callback);
gluTessCallback( tobj, GLU_TESS_BEGIN, begin_callback ); gluTessCallback(tobj, GLU_VERTEX, vertex_callback);
gluTessCallback( tobj, GLU_TESS_VERTEX, vertex_callback ); gluTessCallback(tobj, GLU_EDGE_FLAG, edge_callback);
gluTessCallback( tobj, GLU_TESS_END, end_callback ); gluBeginPolygon(tobj);
gluTessCallback( tobj, GLU_TESS_EDGE_FLAG, edge_callback ); for (j = 0; j <= contour_cnt; j++) {
glNewList( list_start + 1, GL_COMPILE );
gluBeginPolygon( tobj );
for ( j = 0 ; j <= contour_cnt ; j++ )
{
point_cnt = contours[j].point_cnt; point_cnt = contours[j].point_cnt;
gluNextContour( tobj, GLU_UNKNOWN ); gluNextContour(tobj, GLU_UNKNOWN);
for (i = 0; i < point_cnt; i++) {
for ( i = 0 ; i < point_cnt ; i++ ) data[0] = (GLdouble) (contours[j].p[i][0]);
{ data[1] = (GLdouble) (contours[j].p[i][1]);
data[0] = (GLdouble)( contours[j].p[i][0] );
data[1] = (GLdouble)( contours[j].p[i][1] );
data[2] = 0.0; data[2] = 0.0;
gluTessVertex( tobj, data, contours[j].p[i] ); gluTessVertex(tobj, data, contours[j].p[i]);
} }
} }
gluEndPolygon(tobj);
gluEndPolygon( tobj ); gluDeleteTess(tobj);
glEndList(); glutMouseFunc(NULL);
glColor3f(1.0, 1.0, 0.0);
gluDeleteTess( tobj ); glLineWidth(1.0);
glutMouseFunc( NULL );
mode = TESSELATED; mode = TESSELATED;
} }
} }
static void left_down( int x1, int y1 )
static void
left_down(int x1, int y1)
{ {
GLfloat P[2]; GLint P[2];
GLuint point_cnt; GLuint point_cnt;
/* translate GLUT into GL coordinates */ /* translate GLUT into GL coordinates */
P[0] = x1; P[0] = x1;
P[1] = height - y1; P[1] = height - y1;
point_cnt = contours[contour_cnt].point_cnt; point_cnt = contours[contour_cnt].point_cnt;
contours[contour_cnt].p[point_cnt][0] = P[0]; contours[contour_cnt].p[point_cnt][0] = P[0];
contours[contour_cnt].p[point_cnt][1] = P[1]; contours[contour_cnt].p[point_cnt][1] = P[1];
glBegin(GL_LINES);
glBegin( GL_LINES ); if (point_cnt) {
glVertex2iv(contours[contour_cnt].p[point_cnt - 1]);
if ( point_cnt ) glVertex2iv(P);
{
glVertex2fv( contours[contour_cnt].p[point_cnt-1] );
glVertex2fv( P );
} }
else else {
{ glVertex2iv(P);
glVertex2fv( P ); glVertex2iv(P);
glVertex2fv( P );
} }
glEnd(); glEnd();
glFinish(); glFinish();
++(contours[contour_cnt].point_cnt);
contours[contour_cnt].point_cnt++;
} }
static void middle_down( int x1, int y1 )
static void
middle_down(int x1, int y1)
{ {
GLuint point_cnt; GLuint point_cnt;
(void) x1;
(void) y1;
point_cnt = contours[contour_cnt].point_cnt; point_cnt = contours[contour_cnt].point_cnt;
if (point_cnt > 2) {
if ( point_cnt > 2 ) glBegin(GL_LINES);
{ glVertex2iv(contours[contour_cnt].p[0]);
glBegin( GL_LINES ); glVertex2iv(contours[contour_cnt].p[point_cnt - 1]);
glVertex2fv( contours[contour_cnt].p[0] );
glVertex2fv( contours[contour_cnt].p[point_cnt-1] );
contours[contour_cnt].p[point_cnt][0] = -1; contours[contour_cnt].p[point_cnt][0] = -1;
glEnd(); glEnd();
glFinish(); glFinish();
contour_cnt++; contour_cnt++;
contours[contour_cnt].point_cnt = 0; contours[contour_cnt].point_cnt = 0;
} }
} }
static void mouse_clicked( int button, int state, int x, int y )
{
x -= x%10;
y -= y%10;
switch ( button ) static void
{ mouse_clicked(int button, int state, int x, int y)
{
x -= x % 10;
y -= y % 10;
switch (button) {
case GLUT_LEFT_BUTTON: case GLUT_LEFT_BUTTON:
if ( state == GLUT_DOWN ) { if (state == GLUT_DOWN)
left_down( x, y ); left_down(x, y);
}
break; break;
case GLUT_MIDDLE_BUTTON: case GLUT_MIDDLE_BUTTON:
if ( state == GLUT_DOWN ) { if (state == GLUT_DOWN)
middle_down( x, y ); middle_down(x, y);
}
break; break;
} }
} }
static void display( void )
static void
display(void)
{ {
GLuint i,j; GLuint i, j;
GLuint point_cnt; GLuint point_cnt;
glClear( GL_COLOR_BUFFER_BIT ); glClear(GL_COLOR_BUFFER_BIT);
switch (mode) {
switch ( mode )
{
case DEFINE: case DEFINE:
/* draw grid */ /* draw grid */
glColor3f( 0.6, 0.5, 0.5 ); glColor3f(0.6, 0.5, 0.5);
glBegin(GL_LINES);
glBegin( GL_LINES ); for (i = 0; i < width; i += 10)
for (j = 0; j < height; j += 10) {
for ( i = 0 ; i < width ; i += 10 ) glVertex2i(0, j);
{ glVertex2i(width, j);
for ( j = 0 ; j < height ; j += 10 ) glVertex2i(i, height);
{ glVertex2i(i, 0);
glVertex2i( 0, j );
glVertex2i( width, j );
glVertex2i( i, height );
glVertex2i( i, 0 );
} }
}
glEnd(); glEnd();
glColor3f(1.0, 1.0, 0.0);
glColor3f( 1.0, 1.0, 0.0 ); for (i = 0; i <= contour_cnt; i++) {
for ( i = 0 ; i <= contour_cnt ; i++ )
{
point_cnt = contours[i].point_cnt; point_cnt = contours[i].point_cnt;
glBegin(GL_LINES);
glBegin( GL_LINES ); switch (point_cnt) {
switch ( point_cnt )
{
case 0: case 0:
break; break;
case 1: case 1:
glVertex2fv( contours[i].p[0] ); glVertex2iv(contours[i].p[0]);
glVertex2fv( contours[i].p[0] ); glVertex2iv(contours[i].p[0]);
break; break;
case 2: case 2:
glVertex2fv( contours[i].p[0] ); glVertex2iv(contours[i].p[0]);
glVertex2fv( contours[i].p[1] ); glVertex2iv(contours[i].p[1]);
break; break;
default: default:
--point_cnt; --point_cnt;
for ( j = 0 ; j < point_cnt ; j++ ) for (j = 0; j < point_cnt; j++) {
{ glVertex2iv(contours[i].p[j]);
glVertex2fv( contours[i].p[j] ); glVertex2iv(contours[i].p[j + 1]);
glVertex2fv( contours[i].p[j+1] );
} }
if ( contours[i].p[j+1][0] == -1 ) if (contours[i].p[j + 1][0] == -1) {
{ glVertex2iv(contours[i].p[0]);
glVertex2fv( contours[i].p[0] ); glVertex2iv(contours[i].p[j]);
glVertex2fv( contours[i].p[j] );
} }
break; break;
} }
glEnd(); glEnd();
} }
glFinish(); glFinish();
break; break;
case TESSELATED: case TESSELATED:
/* draw triangles */ /* draw lines */
glColor3f( 0.7, 0.7, 0.0 ); tesse();
glCallList( list_start );
glLineWidth( 2.0 );
glCallList( list_start + 1 );
glLineWidth( 1.0 );
glFlush();
break; break;
} }
glColor3f( 1.0, 1.0, 0.0 ); glColor3f(1.0, 1.0, 0.0);
} }
static void clear( void )
static void
clear(void)
{ {
contour_cnt = 0; contour_cnt = 0;
contours[0].point_cnt = 0; contours[0].point_cnt = 0;
triangle_cnt = 0; glutMouseFunc(mouse_clicked);
glutMouseFunc( mouse_clicked );
mode = DEFINE; mode = DEFINE;
display();
glDeleteLists( list_start, 2 );
list_start = 0;
} }
static void quit( void )
static void
quit(void)
{ {
exit( 0 ); exit(0);
} }
static void menu_selected( int entry )
static void
menu_selected(int entry)
{ {
switch ( entry ) switch (entry) {
{
case CLEAR: case CLEAR:
clear(); clear();
break; break;
@@ -438,99 +336,87 @@ static void menu_selected( int entry )
quit(); quit();
break; break;
} }
glutPostRedisplay();
} }
static void key_pressed( unsigned char key, int x, int y )
{
(void) x;
(void) y;
switch ( key ) static void
{ key_pressed(unsigned char key, int x, int y)
case 'c': {
case 'C': switch (key) {
clear();
break;
case 't': case 't':
case 'T': case 'T':
tesse(); tesse();
glFinish();
break; break;
case 'q': case 'q':
case 'Q': case 'Q':
quit(); quit();
break; break;
case 'c':
case 'C':
clear();
break;
} }
glutPostRedisplay();
} }
static void myinit( void )
static void
myinit(void)
{ {
/* clear background to gray */ /* clear background to gray */
glClearColor( 0.4, 0.4, 0.4, 0.0 ); glClearColor(0.4, 0.4, 0.4, 0.0);
glShadeModel( GL_FLAT ); glShadeModel(GL_FLAT);
glPolygonMode( GL_FRONT, GL_FILL );
menu = glutCreateMenu( menu_selected );
glutAddMenuEntry( "clear", CLEAR );
glutAddMenuEntry( "tesselate", TESSELATE );
glutAddMenuEntry( "quit", QUIT );
glutAttachMenu( GLUT_RIGHT_BUTTON );
glutMouseFunc( mouse_clicked );
glutKeyboardFunc( key_pressed );
menu = glutCreateMenu(menu_selected);
glutAddMenuEntry("clear", CLEAR);
glutAddMenuEntry("tesselate", TESSELATE);
glutAddMenuEntry("quit", QUIT);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMouseFunc(mouse_clicked);
glutKeyboardFunc(key_pressed);
contour_cnt = 0; contour_cnt = 0;
glPolygonMode(GL_FRONT, GL_FILL);
mode = DEFINE; mode = DEFINE;
} }
static void reshape( GLsizei w, GLsizei h )
static void
reshape(GLsizei w, GLsizei h)
{ {
glViewport( 0, 0, w, h ); glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glMatrixMode( GL_PROJECTION );
glLoadIdentity(); glLoadIdentity();
glOrtho( 0.0, (GLdouble)w, 0.0, (GLdouble)h, -1.0, 1.0 ); glOrtho(0.0, (GLdouble) w, 0.0, (GLdouble) h, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity(); glLoadIdentity();
set_screen_wh(w, h);
set_screen_wh( w, h );
} }
static void usage( void ) static void
usage(void)
{ {
printf( "Use left mouse button to place vertices.\n" ); printf("Use left mouse button to place vertices.\n");
printf( "Press middle mouse button when done.\n" ); printf("Press middle mouse button when done.\n");
printf( "Select tesselate from the pop-up menu.\n" ); printf("Select tesselate from the pop-up menu.\n");
} }
/* /* Main Loop
* Main Loop * Open window with initial window size, title bar,
* Open window with initial window size, title bar, * RGBA display mode, and handle input events.
* RGBA display mode, and handle input events.
*/ */
int main( int argc, char **argv ) int
main(int argc, char **argv)
{ {
usage(); usage();
glutInit(&argc, argv);
glutInit( &argc, argv ); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitDisplayMode( GLUT_SINGLE | GLUT_RGB ); glutInitWindowSize(400, 400);
glutInitWindowSize( 400, 400 ); glutCreateWindow(argv[0]);
glutCreateWindow( argv[0] ); myinit();
glutDisplayFunc(display);
myinit(); glutReshapeFunc(reshape);
glutMainLoop();
glutDisplayFunc( display ); return 0;
glutReshapeFunc( reshape );
glutMainLoop();
return 0;
} }