void compoe_jato(void){ GLUquadricObj *quadric; GLfloat asa[][3]={ {-4.0,0.0,0.0}, {+4.0,0.0,0.0}, {0.0,0.0,3.0} }; GLfloat cauda[][3]={ {0.0,0.0,0.0}, {0.0,2.0,-1.0}, {0.0,2.0,0.0}, {0.0,0.0,2.0} }; GLfloat logo[][3]={ {0.01,1.5,0}, {0.01,2,0}, {0.01,2,-0.6}, {0.01,1.5,-0.6} }; /* inicia a composicao do jato */ jato = glGenLists(1); glNewList(jato, GL_COMPILE); /* asas */ glBegin(GL_TRIANGLES); glTexCoord2fv(cta[0]); glVertex3fv(asa[0]); glTexCoord2fv(cta[1]); glVertex3fv(asa[1]); glTexCoord2fv(cta[3]); glVertex3fv(asa[2]); glEnd(); /* corpo */ quadric = gluNewQuadric(); gluQuadricTexture(quadric, GL_TRUE); gluCylinder(quadric, 0.5, 0.5, 4, 12, 3); /* nariz */ quadric = gluNewQuadric(); gluQuadricTexture(quadric, GL_TRUE); glPushMatrix(); glTranslatef(0,0,4); gluCylinder(quadric, 0.5, 0.0, 1.5, 12, 3); glPopMatrix(); /* Turbina */ quadric = gluNewQuadric(); glPushMatrix(); glTranslatef(0,0,-0.5); glColor4f(0.2,0.2,0.3,1); glDisable(GL_TEXTURE_2D); gluCylinder(quadric, 0.3, 0.5, 0.5, 12, 3); glEnable(GL_TEXTURE_2D); glPopMatrix(); /* Fogo */ quadric = gluNewQuadric(); gluQuadricTexture(quadric, GL_TRUE); glPushMatrix(); glTranslatef(0,0,-1.4); glColor4f(1,0.2,0.0,0.5); glDisable(GL_TEXTURE_2D); gluCylinder(quadric, 0.0, 0.5, 1.8, 12, 3); glEnable(GL_TEXTURE_2D); glPopMatrix(); /* cauda */ glColor4f(0,0.0,0.0,1); glBegin(GL_POLYGON); glTexCoord2fv(cta[0]); glVertex3fv(cauda[0]); glTexCoord2fv(cta[1]); glVertex3fv(cauda[1]); glTexCoord2fv(cta[2]); glVertex3fv(cauda[2]); glTexCoord2fv(cta[3]); glVertex3fv(cauda[3]); glEnd(); /* logo */ glColor4f(0,0.0,0.0,1); glBindTexture(GL_TEXTURE_2D,textura_logo); glBegin(GL_QUADS); glTexCoord2fv(ctl[0]); glVertex3fv(logo[0]); glTexCoord2fv(ctl[1]); glVertex3fv(logo[1]); glTexCoord2fv(ctl[2]); glVertex3fv(logo[2]); glTexCoord2fv(ctl[3]); glVertex3fv(logo[3]); glEnd(); /* cabine do piloto */ glTranslatef(0,0.3,3.5); glPushMatrix(); glScalef(0.7,0.7,2.0); quadric=gluNewQuadric(); glColor4f(0.3,0.5,1,0.5); glDisable(GL_TEXTURE_2D); gluSphere(quadric,0.5,12,12); glPopMatrix(); /* termina a composicao do jato*/ glEndList(); }
ENTRYPOINT void init_cube (ModeInfo *mi) { cube_configuration *bp; int wire = MI_IS_WIREFRAME(mi); int i; if (!bps) { bps = (cube_configuration *) calloc (MI_NUM_SCREENS(mi), sizeof (cube_configuration)); if (!bps) { fprintf(stderr, "%s: out of memory\n", progname); exit(1); } } bp = &bps[MI_SCREEN(mi)]; bp->glx_context = init_GL(mi); reshape_cube (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); glShadeModel(GL_SMOOTH); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_CULL_FACE); if (!wire) { GLfloat pos[4] = {0.7, 0.2, 0.4, 0.0}; /* GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};*/ GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0}; GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0}; GLfloat spc[4] = {1.0, 1.0, 1.0, 1.0}; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glLightfv(GL_LIGHT0, GL_POSITION, pos); glLightfv(GL_LIGHT0, GL_AMBIENT, amb); glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); glLightfv(GL_LIGHT0, GL_SPECULAR, spc); } bp->trackball = gltrackball_init (); bp->dlists = (GLuint *) calloc (countof(all_objs)+2, sizeof(GLuint)); for (i = 0; i < countof(all_objs)+1; i++) bp->dlists[i] = glGenLists (1); for (i = 0; i < countof(all_objs); i++) { const struct gllist *gll = *all_objs[i]; glNewList (bp->dlists[i], GL_COMPILE); renderList (gll, wire); glEndList (); } glNewList (bp->dlists[i], GL_COMPILE); bp->cube_polys = build_cube (mi); glEndList (); bp->nfloaters = MI_COUNT (mi); bp->floaters = (floater *) calloc (bp->nfloaters, sizeof (floater)); for (i = 0; i < bp->nfloaters; i++) { floater *f = &bp->floaters[i]; double spin_speed = do_spin ? 0.7 : 10; double wander_speed = do_wander ? 0.02 : 0.05 * speed * SPEED_SCALE; double spin_accel = 0.5; f->rot = make_rotator (spin_speed, spin_speed, spin_speed, spin_accel, wander_speed, True); if (bp->nfloaters == 2) { f->x = (i ? 2 : -2); } else if (i != 0) { double th = (i - 1) * M_PI*2 / (bp->nfloaters-1); double r = 3; f->x = r * cos(th); f->z = r * sin(th); } f->ix = f->x; f->iy = f->y; f->iz = f->z; reset_floater (mi, f); } }
static void updateElementTextures (CompScreen *s, Bool changeTextures) { int i, count = 0; float autumnSize = elementsGetLeafSize(s->display); float ffSize = elementsGetFireflySize(s->display); float snowSize = elementsGetSnowSize(s->display); float starsSize = elementsGetStarsSize(s->display); float bubblesSize = elementsGetBubblesSize(s->display); element *ele; E_SCREEN (s); E_DISPLAY (s->display); int numAutumn, numFf, numSnow, numStars, numBubbles; if (eScreen->isActive[0]) numAutumn = elementsGetNumLeaves (s->display); else numAutumn = 0; if (eScreen->isActive[1]) numFf = elementsGetNumFireflies (s->display); else numFf = 0; if (eScreen->isActive[2]) numSnow = elementsGetNumSnowflakes (s->display); else numSnow = 0; if (eScreen->isActive[3]) numStars = elementsGetNumStars (s->display); else numStars = 0; if (eScreen->isActive[4]) numBubbles = elementsGetNumBubbles (s->display); else numBubbles = 0; ele = eScreen->allElements; if (changeTextures) { for (i = 0; i < eScreen->numElements; i++) { finiTexture (s, &eScreen->textu[i].tex); glDeleteLists (eScreen->textu[i].dList, 1); } if (eScreen->textu) free (eScreen->textu); eScreen->numElements = 0; eScreen->numTexLoaded[0] = 0; eScreen->numTexLoaded[1] = 0; eScreen->numTexLoaded[2] = 0; eScreen->numTexLoaded[3] = 0; eScreen->numTexLoaded[4] = 0; eScreen->textu = calloc (1, sizeof (texture) * (ed->numTex[0] + ed->numTex[1] + ed->numTex[2] + ed->numTex[3] + ed->numTex[4])); } for (i = 0; i < ed->numTex[0]; i++) { CompMatrix *mat; texture *aTex; if (changeTextures) { eScreen->textu[count].loaded = readImageToTexture (s, &eScreen->textu[count].tex, ed->texFiles[0][i].s, &eScreen->textu[count].width, &eScreen->textu[count].height); if (!eScreen->textu[count].loaded) { compLogMessage ("Elements", CompLogLevelWarn, "Texture (Autumn) not found : %s", ed->texFiles[0][i].s); continue; } compLogMessage ("Elements", CompLogLevelInfo, "Loaded Texture (Autumn)%s", ed->texFiles[0][i].s); } mat = &eScreen->textu[count].tex.matrix; aTex = &eScreen->textu[count]; aTex->dList = glGenLists (1); glNewList (aTex->dList, GL_COMPILE); glBegin (GL_QUADS); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (0, 0); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (0, autumnSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (autumnSize, autumnSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (autumnSize, 0); glEnd (); glEndList (); count++; } if (changeTextures) eScreen->numTexLoaded[0] = count; for (i = 0; i < ed->numTex[1]; i++) { CompMatrix *mat; texture *aTex; if (changeTextures) { eScreen->textu[count].loaded = readImageToTexture (s, &eScreen->textu[count].tex, ed->texFiles[1][i].s, &eScreen->textu[count].width, &eScreen->textu[count].height); if (!eScreen->textu[count].loaded) { compLogMessage ("Elements", CompLogLevelWarn, "Texture (Firefly) not found : %s", ed->texFiles[1][i].s); continue; } compLogMessage ("Elements", CompLogLevelInfo, "Loaded Texture (Firefly) %s", ed->texFiles[1][i].s); } mat = &eScreen->textu[count].tex.matrix; aTex = &eScreen->textu[count]; aTex->dList = glGenLists (1); glNewList (aTex->dList, GL_COMPILE); glBegin (GL_QUADS); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (0, 0); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (0, ffSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (ffSize, ffSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (ffSize, 0); glEnd (); glEndList (); count++; } if (changeTextures) eScreen->numTexLoaded[1] = count - eScreen->numTexLoaded[0]; for (i = 0; i < ed->numTex[2]; i++) { CompMatrix *mat; texture *aTex; if (changeTextures) { eScreen->textu[count].loaded = readImageToTexture (s, &eScreen->textu[count].tex, ed->texFiles[2][i].s, &eScreen->textu[count].width, &eScreen->textu[count].height); if (!eScreen->textu[count].loaded) { compLogMessage ("Elements", CompLogLevelWarn, "Texture (snow) not found : %s", ed->texFiles[2][i].s); continue; } compLogMessage ("Elements", CompLogLevelInfo, "Loaded Texture (snow) %s", ed->texFiles[2][i].s); } mat = &eScreen->textu[count].tex.matrix; aTex = &eScreen->textu[count]; aTex->dList = glGenLists (1); glNewList (aTex->dList, GL_COMPILE); glBegin (GL_QUADS); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (0, 0); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (0, snowSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (snowSize, snowSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (snowSize, 0); glEnd (); glEndList (); count++; } if (changeTextures) eScreen->numTexLoaded[2] = count - eScreen->numTexLoaded[0] -eScreen->numTexLoaded[1]; for (i = 0; i < ed->numTex[3]; i++) { CompMatrix *mat; texture *aTex; if (changeTextures) { eScreen->textu[count].loaded = readImageToTexture (s, &eScreen->textu[count].tex, ed->texFiles[3][i].s, &eScreen->textu[count].width, &eScreen->textu[count].height); if (!eScreen->textu[count].loaded) { compLogMessage ("Elements", CompLogLevelWarn, "Texture (stars) not found : %s", ed->texFiles[3][i].s); continue; } compLogMessage ("Elements", CompLogLevelInfo, "Loaded Texture (stars)%s", ed->texFiles[3][i].s); } mat = &eScreen->textu[count].tex.matrix; aTex = &eScreen->textu[count]; aTex->dList = glGenLists (1); glNewList (aTex->dList, GL_COMPILE); glBegin (GL_QUADS); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (0, 0); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (0, starsSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (starsSize, starsSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (starsSize, 0); glEnd (); glEndList (); count++; } if (changeTextures) eScreen->numTexLoaded[3] = count - eScreen->numTexLoaded[0] - eScreen->numTexLoaded[1] - eScreen->numTexLoaded[2]; for (i = 0; i < ed->numTex[4]; i++) { CompMatrix *mat; texture *aTex; if (changeTextures) { eScreen->textu[count].loaded = readImageToTexture (s, &eScreen->textu[count].tex, ed->texFiles[4][i].s, &eScreen->textu[count].width, &eScreen->textu[count].height); if (!eScreen->textu[count].loaded) { compLogMessage ("Elements", CompLogLevelWarn, "Texture (bubbles) not found : %s", ed->texFiles[4][i].s); continue; } compLogMessage ("Elements", CompLogLevelInfo, "Loaded Texture (bubbles)%s", ed->texFiles[4][i].s); } mat = &eScreen->textu[count].tex.matrix; aTex = &eScreen->textu[count]; aTex->dList = glGenLists (1); glNewList (aTex->dList, GL_COMPILE); glBegin (GL_QUADS); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (0, 0); glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (0, bubblesSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, aTex->height)); glVertex2f (bubblesSize, bubblesSize * aTex->height / aTex->width); glTexCoord2f (COMP_TEX_COORD_X (mat, aTex->width), COMP_TEX_COORD_Y (mat, 0)); glVertex2f (bubblesSize, 0); glEnd (); glEndList (); count++; } if (changeTextures) { eScreen->numTexLoaded[4] = count - eScreen->numTexLoaded[0] - eScreen->numTexLoaded[1] - eScreen->numTexLoaded[2] - eScreen->numTexLoaded[3]; // if (count < (ed->numTex[0] + ed->numTex[1] + ed->numTex[2] + ed->numTex[3] + ed->numTex[4])) eScreen->textu = realloc (eScreen->textu, sizeof (texture) * count); eScreen->numElements = count; for (i = 0; i < (numAutumn + numFf + numSnow + numStars + numBubbles); i++) setElementTexture (eScreen, ele++); } }
/* build list of hexahedra */ GLuint listHexaMap(pScene sc,pMesh mesh,ubyte clip) { pMaterial pm; pHexa ph; pPoint p0,p1,p2,p3; pSolution ps0,ps1,ps2,ps3; GLint dlist = 0; double ax,ay,az,bx,by,bz,d; float n[3],cx,cy,cz; int k,l,m; triangle t1,t2; if ( !mesh->nhex ) return(0); if ( ddebug ) printf("create display list map / HEXA\n"); if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) ) return(0); /* build display list */ dlist = glGenLists(1); glNewList(dlist,GL_COMPILE); if ( glGetError() ) return(0); /* build list */ for (m=0; m<sc->par.nbmat; m++) { pm = &sc->material[m]; k = pm->depmat[LHexa]; if ( !k || pm->flag ) continue; glBegin(GL_TRIANGLES); while ( k != 0 ) { ph = &mesh->hexa[k]; if ( !ph->v[0] || (clip && !ph->clip) ) { k = ph->nxt; continue; } cx = cy = cz = 0.0f; for (l=0; l<8; l++) { p0 = &mesh->point[ph->v[l]]; cx += p0->c[0]; cy += p0->c[1]; cz += p0->c[2]; } cx /= 8.; cy /= 8.; cz /= 8.; for (l=0; l<6; l++) { p0 = &mesh->point[ph->v[ch[l][0]]]; p1 = &mesh->point[ph->v[ch[l][1]]]; p2 = &mesh->point[ph->v[ch[l][2]]]; p3 = &mesh->point[ph->v[ch[l][3]]]; /* compute face normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; d = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( d > 0.0f ) { d = 1.0f / sqrt(d); n[0] *= d; n[1] *= d; n[2] *= d; } /* store triangles */ t1.a[0] = t2.a[0] = sc->shrink*(p0->c[0]-cx)+cx; t1.a[1] = t2.a[1] = sc->shrink*(p0->c[1]-cy)+cy; t1.a[2] = t2.a[2] = sc->shrink*(p0->c[2]-cz)+cz; t1.b[0] = sc->shrink*(p1->c[0]-cx)+cx; t1.b[1] = sc->shrink*(p1->c[1]-cy)+cy; t1.b[2] = sc->shrink*(p1->c[2]-cz)+cz; t1.c[0] = t2.b[0] = sc->shrink*(p2->c[0]-cx)+cx; t1.c[1] = t2.b[1] = sc->shrink*(p2->c[1]-cy)+cy; t1.c[2] = t2.b[2] = sc->shrink*(p2->c[2]-cz)+cz; t2.c[0] = sc->shrink*(p3->c[0]-cx)+cx; t2.c[1] = sc->shrink*(p3->c[1]-cy)+cy; t2.c[2] = sc->shrink*(p3->c[2]-cz)+cz; /* store normals */ memcpy(t1.na,n,3*sizeof(float)); memcpy(t1.nb,n,3*sizeof(float)); memcpy(t1.nc,n,3*sizeof(float)); memcpy(t2.na,n,3*sizeof(float)); memcpy(t2.nb,n,3*sizeof(float)); memcpy(t2.nc,n,3*sizeof(float)); if ( mesh->typage == 2 ) { /* solutions at vertices */ ps0 = &mesh->sol[ph->v[ch[l][0]]]; ps1 = &mesh->sol[ph->v[ch[l][1]]]; ps2 = &mesh->sol[ph->v[ch[l][2]]]; ps3 = &mesh->sol[ph->v[ch[l][3]]]; t1.va = t2.va = ps0->bb; t1.vb = ps1->bb; t1.vc = t2.vb = ps2->bb; t2.vc = ps3->bb; } else { /* solution at element */ ps0 = &mesh->sol[k]; t1.va = t1.vb = t1.vc = ps0->bb; t2.va = t2.vb = t2.vc = ps0->bb; } /* color interpolation */ cutTriangle(sc,t1); cutTriangle(sc,t2); } k = ph->nxt; } glEnd(); } glEndList(); return(dlist); }
GLWidget::GLWidget(QWidget *parent) : QGLWidget(QGLFormat(QGL::SampleBuffers), parent) { setWindowTitle(tr("OpenGL pbuffers 2")); pbuffer = new QGLPixelBuffer(1024, 1024, format(), this); rot_x = rot_y = rot_z = 0.0f; scale = 0.1f; anim = new QTimeLine(750, this); anim->setUpdateInterval(20); connect(anim, SIGNAL(valueChanged(qreal)), SLOT(animate(qreal))); connect(anim, SIGNAL(finished()), SLOT(animFinished())); svg_renderer = new QSvgRenderer(QLatin1String(":/res/bubbles.svg"), this); connect(svg_renderer, SIGNAL(repaintNeeded()), this, SLOT(draw())); logo = QImage(":/res/designer.png"); logo = logo.convertToFormat(QImage::Format_ARGB32); makeCurrent(); // need a current context to create the display list tile_list = glGenLists(1); glNewList(tile_list, GL_COMPILE); glBegin(GL_QUADS); { glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); } glEnd(); glEndList(); wave = new GLfloat[logo.width()*logo.height()]; memset(wave, 0, logo.width()*logo.height()); startTimer(30); // wave timer pbuffer->makeCurrent(); dynamicTexture = pbuffer->generateDynamicTexture(); // bind the dynamic texture to the pbuffer - this is a no-op under X11 hasDynamicTextureUpdate = pbuffer->bindToDynamicTexture(dynamicTexture); }
/* CONSTRUCTORS */ FFTButton::FFTButton(const Point2f &position, float width, float height) : Button(position, width, height) { fftButtonDirty = true; fftButtonDisplayList = glGenLists(1); }
/* build list of quadrilaterals */ GLuint listQuadMap(pScene sc,pMesh mesh) { pMaterial pm; pQuad pq; pPoint p0,p1,p2,p3; pSolution ps0,ps1,ps2,ps3; GLint dlist = 0; double ax,ay,az,bx,by,bz,dd; float cx,cy,cz,n[3]; int k,m,is0,is1,is2,is3; triangle t1,t2; /* default */ if ( !mesh->nq ) return(0); if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) ) return(0); if ( ddebug ) printf("create display list map / QUADS\n"); /* build display list */ dlist = glGenLists(1); glNewList(dlist,GL_COMPILE); if ( glGetError() ) return(0); /* build list */ for (m=0; m<sc->par.nbmat; m++) { pm = &sc->material[m]; k = pm->depmat[LQuad]; if ( !k || pm->flag ) continue; glBegin(GL_TRIANGLES); while ( k != 0 ) { pq = &mesh->quad[k]; if ( pq->v[0] == 0 ) { k = pq->nxt; continue; } p0 = &mesh->point[pq->v[0]]; p1 = &mesh->point[pq->v[1]]; p2 = &mesh->point[pq->v[2]]; p3 = &mesh->point[pq->v[3]]; /* compute normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( dd > 0.0f ) { dd = 1.0f / sqrt(dd); n[0] *= dd; n[1] *= dd; n[2] *= dd; } if ( sc->shrink < 1.0 ) { cx = 0.25 * (p0->c[0] + p1->c[0] + p2->c[0] + p3->c[0]); cy = 0.25 * (p0->c[1] + p1->c[1] + p2->c[1] + p3->c[1]); cz = 0.25 * (p0->c[2] + p1->c[2] + p2->c[2] + p3->c[2]); t1.a[0] = t2.a[0] = sc->shrink*(p0->c[0]-cx)+cx; t1.a[1] = t2.a[1] = sc->shrink*(p0->c[1]-cy)+cy; t1.a[2] = t2.a[2] = sc->shrink*(p0->c[2]-cz)+cz; t1.b[0] = sc->shrink*(p1->c[0]-cx)+cx; t1.b[1] = sc->shrink*(p1->c[1]-cy)+cy; t1.b[2] = sc->shrink*(p1->c[2]-cz)+cz; t1.c[0] = t2.b[0] = sc->shrink*(p2->c[0]-cx)+cx; t1.c[1] = t2.b[1] = sc->shrink*(p2->c[1]-cy)+cy; t1.c[2] = t2.b[2] = sc->shrink*(p2->c[2]-cz)+cz; t2.c[0] = sc->shrink*(p3->c[0]-cx)+cx; t2.c[1] = sc->shrink*(p3->c[1]-cy)+cy; t2.c[2] = sc->shrink*(p3->c[2]-cz)+cz; } else { t1.a[0] = t2.a[0] = p0->c[0]; t1.a[1] = t2.a[1] = p0->c[1]; t1.a[2] = t2.a[2] = p0->c[2]; t1.b[0] = p1->c[0]; t1.b[1] = p1->c[1]; t1.b[2] = p1->c[2]; t1.c[0] = t2.b[0] = p2->c[0]; t1.c[1] = t2.b[1] = p2->c[1]; t1.c[2] = t2.b[2] = p2->c[2]; t2.c[0] = p3->c[0]; t2.c[1] = p3->c[1]; t2.c[2] = p3->c[2]; } if ( sc->type & S_FLAT ) { memcpy(t1.na,n,3*sizeof(float)); memcpy(t1.nb,n,3*sizeof(float)); memcpy(t1.nc,n,3*sizeof(float)); memcpy(t2.na,n,3*sizeof(float)); memcpy(t2.nb,n,3*sizeof(float)); memcpy(t2.nc,n,3*sizeof(float)); } else { is0 = is1 = is2 = is3 = 0; if ( mesh->extra->iv ) { if ( pq->v[0] <= mesh->nvn ) is0 = mesh->extra->nv[pq->v[0]]; if ( pq->v[1] <= mesh->nvn ) is1 = mesh->extra->nv[pq->v[1]]; if ( pq->v[2] <= mesh->nvn ) is2 = mesh->extra->nv[pq->v[2]]; if ( pq->v[3] <= mesh->nvn ) is3 = mesh->extra->nv[pq->v[3]]; } if ( !is0 && pq->v[0] <= mesh->extra->iq ) is0 = mesh->extra->nq[4*(k-1)+1]; if ( !is1 && pq->v[1] <= mesh->extra->iq ) is1 = mesh->extra->nq[4*(k-1)+2]; if ( !is2 && pq->v[2] <= mesh->extra->iq ) is2 = mesh->extra->nq[4*(k-1)+3]; if ( !is3 && pq->v[3] <= mesh->extra->iq ) is3 = mesh->extra->nq[4*(k-1)+4]; if ( !is0 ) memcpy(t1.na,n,3*sizeof(float)); else { t1.na[0] = t2.na[0] = mesh->extra->n[3*(is0-1)+1]; t1.na[1] = t2.na[1] = mesh->extra->n[3*(is0-1)+2]; t1.na[2] = t2.na[2] = mesh->extra->n[3*(is0-1)+3]; } if ( !is1 ) memcpy(t1.nb,n,3*sizeof(float)); else { t1.nb[0] = mesh->extra->n[3*(is1-1)+1]; t1.nb[1] = mesh->extra->n[3*(is1-1)+2]; t1.nb[2] = mesh->extra->n[3*(is1-1)+3]; } if ( !is2 ) memcpy(t1.nc,n,3*sizeof(float)); else { t1.nc[0] = t2.nb[0] = mesh->extra->n[3*(is2-1)+1]; t1.nc[1] = t2.nb[1] = mesh->extra->n[3*(is2-1)+2]; t1.nc[2] = t2.nb[2] = mesh->extra->n[3*(is2-1)+3]; } if ( !is3 ) memcpy(t1.nc,n,3*sizeof(float)); else { t2.nc[0] = mesh->extra->n[3*(is3-1)+1]; t2.nc[1] = mesh->extra->n[3*(is3-1)+2]; t2.nc[2] = mesh->extra->n[3*(is3-1)+3]; } } if ( mesh->typage == 2 ) { /* solutions at vertices */ ps0 = &mesh->sol[pq->v[0]]; ps1 = &mesh->sol[pq->v[1]]; ps2 = &mesh->sol[pq->v[2]]; ps3 = &mesh->sol[pq->v[3]]; t1.va = t2.va = ps0->bb; t1.vb = ps1->bb; t1.vc = t2.vb = ps2->bb; t2.vc = ps3->bb; } else { /* solution at element */ ps0 = &mesh->sol[k]; t1.va = t1.vb = t1.vc = ps0->bb; t2.va = t2.vb = t2.vc = ps0->bb; } /* color interpolation */ cutTriangle(sc,t1); cutTriangle(sc,t2); k = pq->nxt; } glEnd(); } glEndList(); return(dlist); }
GLuint genSceneDisplayList(std::vector<carve::mesh::MeshSet<3> *> &polys, std::vector<carve::line::PolylineSet *> &lines, std::vector<carve::point::PointSet *> &points, size_t *listSize, std::vector<bool> &is_wireframe) { int n = 0; int N = 1; is_wireframe.clear(); if (options.wireframe) N = 2; for (size_t p = 0; p < polys.size(); ++p) n += polys[p]->meshes.size() * N + 1; for (size_t p = 0; p < lines.size(); ++p) n += lines[p]->lines.size() * 2; n += points.size(); if (n == 0) return 0; carve::geom3d::AABB aabb; if (polys.size()) { aabb = polys[0]->getAABB(); } else if (lines.size()) { aabb = lines[0]->aabb; } else if (points.size()) { aabb = points[0]->aabb; } for (size_t p = 0; p < polys.size(); ++p) aabb.unionAABB(polys[p]->getAABB()); for (size_t p = 0; p < lines.size(); ++p) { std::cerr << lines[p]->aabb << std::endl; aabb.unionAABB(lines[p]->aabb); } for (size_t p = 0; p < points.size(); ++p) aabb.unionAABB(points[p]->aabb); GLuint dlist = glGenLists((GLsizei)(*listSize = n)); is_wireframe.resize(n, false); double scale_fac = 20.0 / aabb.extent[carve::geom::largestAxis(aabb.extent)]; if (options.fit) { g_translation = -aabb.pos; g_scale = scale_fac; } else { g_translation = carve::geom::VECTOR(0.0,0.0,0.0); g_scale = 1.0; } unsigned list_num = 0; for (size_t p = 0; p < polys.size(); ++p) { carve::mesh::MeshSet<3> *poly = polys[p]; glEnable(GL_CULL_FACE); for (unsigned i = 0; i < poly->meshes.size(); i++) { if (!poly->meshes[i]->isClosed()) { is_wireframe[list_num] = false; glNewList(dlist + list_num++, GL_COMPILE); glCullFace(GL_BACK); drawMeshSet(poly, 0.3f, 0.8f, 0.5f, 1.0f, i); glCullFace(GL_FRONT); drawMeshSet(poly, 0.0f, 0.0f, 1.0f, 1.0f, i); glCullFace(GL_BACK); glEndList(); if (options.wireframe) { is_wireframe[list_num] = true; glNewList(dlist + list_num++, GL_COMPILE); drawMeshSetWireframe(poly, i, options.normal, options.edgeconn); glEndList(); } } } for (unsigned i = 0; i < poly->meshes.size(); i++) { if (poly->meshes[i]->isClosed()) { is_wireframe[list_num] = false; glNewList(dlist + list_num++, GL_COMPILE); glCullFace(GL_BACK); drawMeshSet(poly, 0.3f, 0.5f, 0.8f, 1.0f, i); glCullFace(GL_FRONT); drawMeshSet(poly, 1.0f, 0.0f, 0.0f, 1.0f, i); glCullFace(GL_BACK); glEndList(); if (options.wireframe) { is_wireframe[list_num] = true; glNewList(dlist + list_num++, GL_COMPILE); drawMeshSetWireframe(poly, i, options.normal, options.edgeconn); glEndList(); } } } typedef carve::geom::RTreeNode<3, carve::mesh::Face<3> *> face_rtree_t; face_rtree_t *tree = face_rtree_t::construct_STR(poly->faceBegin(), poly->faceEnd(), 4, 4); // face_rtree_t *tree = face_rtree_t::construct_TGS(poly->faceBegin(), poly->faceEnd(), 50, 4); is_wireframe[list_num] = true; glNewList(dlist + list_num++, GL_COMPILE); // drawTree(tree); glEndList(); delete tree; } for (size_t l = 0; l < lines.size(); ++l) { carve::line::PolylineSet *line = lines[l]; for (carve::line::PolylineSet::line_iter i = line->lines.begin(); i != line->lines.end(); ++i) { is_wireframe[list_num] = false; glNewList(dlist + list_num++, GL_COMPILE); glBegin((*i)->isClosed() ? GL_LINE_LOOP : GL_LINE_STRIP); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); for (carve::line::polyline_vertex_iter j = (*i)->vbegin(); j != (*i)->vend(); ++j) { carve::geom3d::Vector v = (*j)->v; glVertex3f(g_scale * (v.x + g_translation.x), g_scale * (v.y + g_translation.y), g_scale * (v.z + g_translation.z)); } glEnd(); glEndList(); is_wireframe[list_num] = true; glNewList(dlist + list_num++, GL_COMPILE); glPointSize(4.0); glColor4f(1.0f, 1.0f, 0.0f, 1.0f); glBegin(GL_POINTS); for (carve::line::polyline_vertex_iter j = (*i)->vbegin(); j != (*i)->vend(); ++j) { carve::geom3d::Vector v = (*j)->v; glVertex3f(g_scale * (v.x + g_translation.x), g_scale * (v.y + g_translation.y), g_scale * (v.z + g_translation.z)); } glEnd(); glEndList(); } } for (size_t l = 0; l < points.size(); ++l) { carve::point::PointSet *point = points[l]; is_wireframe[list_num] = false; glNewList(dlist + list_num++, GL_COMPILE); glPointSize(4.0); glBegin(GL_POINTS); for (size_t i = 0; i < point->vertices.size(); ++i) { carve::geom3d::Vector v = point->vertices[i].v; glColor4f(0.0f, 1.0f, 1.0f, 1.0f); glVertex3f(g_scale * (v.x + g_translation.x), g_scale * (v.y + g_translation.y), g_scale * (v.z + g_translation.z)); } glEnd(); glEndList(); } return dlist; }
// This function does any needed initialization on the rendering // context. void SetupRC() { GLint iWidth, iHeight,iComponents; GLenum eFormat; GLbyte *pBytes; GLfloat fAmbLight[] = { 0.1f, 0.1f, 0.1f, 0.0f }; GLfloat fDiffLight[] = { 1.0f, 1.0f, 1.0f, 0.0f }; GLfloat fSpecLight[] = { 0.5f, 0.5f, 0.5f, 0.0f }; GLfloat lightPos[] = { -100.0f, 100.0f, 100.0f, 1.0f }; GLfloat fScale = 0.01f; // Bluish background glClearColor(0.0f, 0.0f, .50f, 1.0f ); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); // Lit texture environment glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glGenTextures(2, textureObjects); // Load the body texture glBindTexture(GL_TEXTURE_2D, textureObjects[BODY_TEXTURE]); pBytes = gltLoadTGA("BODY.tga", &iWidth, &iHeight, &iComponents, &eFormat); glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, (void *)pBytes); free(pBytes); GLfloat fLargest; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glBindTexture(GL_TEXTURE_2D, textureObjects[GLASS_TEXTURE]); pBytes = gltLoadTGA("glass.tga", &iWidth, &iHeight, &iComponents, &eFormat); glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, (void *)pBytes); free(pBytes); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glEnable(GL_TEXTURE_2D); // Set up lighting glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT, GL_SPECULAR, fDiffLight); glMateriali(GL_FRONT, GL_SHININESS, 128); glLightfv(GL_LIGHT0, GL_AMBIENT, fAmbLight); glLightfv(GL_LIGHT0, GL_DIFFUSE, fDiffLight); glLightfv(GL_LIGHT0, GL_SPECULAR, fSpecLight); glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); // Light never changes, put it here glLightfv(GL_LIGHT0, GL_POSITION, lightPos); glEnable(GL_RESCALE_NORMAL); bodyList = glGenLists(2); glassList = bodyList + 1; glNewList(bodyList, GL_COMPILE); DrawBody(); glEndList(); glNewList(glassList, GL_COMPILE); DrawGlass(); glEndList(); }
static void draw_surface( unsigned int with_state ) { GLint i, j; if (with_state & DISPLAYLIST) { if ((with_state & (RENDER_STYLE_MASK|PRIMITIVE_MASK|MATERIAL_MASK)) != dlist_state) { /* */ fprintf(stderr, "rebuilding displaylist\n"); if (dlist_state) glDeleteLists( surf1, 1 ); dlist_state = with_state & (RENDER_STYLE_MASK|PRIMITIVE_MASK| MATERIAL_MASK); surf1 = glGenLists(1); glNewList(surf1, GL_COMPILE); draw_surface( dlist_state ); glEndList(); } glCallList( surf1 ); return; } switch (with_state & (RENDER_STYLE_MASK|PRIMITIVE_MASK)) { #ifdef GL_EXT_vertex_array case (DRAW_ELTS|TRIANGLES): if (with_state & MATERIALS) { for (j = i = 0 ; i < num_tri_verts ; i += 600, j++) { GLuint nr = MIN(num_tri_verts-i, 600); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, col[j]); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, col[j]); glDrawElements( GL_TRIANGLES, nr, GL_UNSIGNED_INT, tri_indices+i ); } } else { glDrawElements( GL_TRIANGLES, num_tri_verts, GL_UNSIGNED_INT, tri_indices ); } break; case (DRAW_ARRAYS|TRIANGLES): glDrawArraysEXT( GL_TRIANGLES, 0, (numverts-2)*3 ); break; case (ARRAY_ELT|TRIANGLES): if (with_state & MATERIALS) { for (j = i = 0 ; i < num_tri_verts ; i += 600, j++) { GLuint nr = MIN(num_tri_verts-i, 600); GLuint k; glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, col[j]); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, col[j]); glBegin( GL_TRIANGLES ); for (k = 0 ; k < nr ; k++) glArrayElement( tri_indices[i+k] ); glEnd(); } } else { glBegin( GL_TRIANGLES ); for (i = 0 ; i < num_tri_verts ; i++) glArrayElement( tri_indices[i] ); glEnd(); } break; /* Uses the original arrays (including duplicate elements): */ case (DRAW_ARRAYS|STRIPS): glDrawArraysEXT( GL_TRIANGLE_STRIP, 0, numverts ); break; case (DRAW_ELTS|STRIPS): glDrawElements( GL_TRIANGLE_STRIP, numverts, GL_UNSIGNED_INT, strip_indices ); break; /* Uses the original arrays (including duplicate elements): */ case (ARRAY_ELT|STRIPS): glBegin( GL_TRIANGLE_STRIP ); for (i = 0 ; i < numverts ; i++) glArrayElement( i ); glEnd(); break; case (DRAW_ARRAYS|POINTS): glDrawArraysEXT( GL_POINTS, 0, numuniq ); break; case (DRAW_ELTS|POINTS): /* can use numuniq with strip_indices as strip_indices[i] == i. */ glDrawElements( GL_POINTS, numuniq, GL_UNSIGNED_INT, strip_indices ); break; case (ARRAY_ELT|POINTS): /* just emit each unique element once: */ glBegin( GL_POINTS ); for (i = 0 ; i < numuniq ; i++) glArrayElement( i ); glEnd(); break; #endif case (GLVERTEX|TRIANGLES): if (with_state & MATERIALS) { for (j = i = 0 ; i < num_tri_verts ; i += 600, j++) { GLuint nr = MIN(num_tri_verts-i, 600); GLuint k; glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, col[j]); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, col[j]); glBegin( GL_TRIANGLES ); for (k = 0 ; k < nr ; k++) { glNormal3fv( &compressed_data[tri_indices[i+k]][3] ); glVertex3fv( &compressed_data[tri_indices[i+k]][0] ); } glEnd(); } } else { glBegin( GL_TRIANGLES ); for (i = 0 ; i < num_tri_verts ; i++) { glNormal3fv( &compressed_data[tri_indices[i]][3] ); glVertex3fv( &compressed_data[tri_indices[i]][0] ); } glEnd(); } break; case (GLVERTEX|POINTS): /* Renders all points, but not in strip order... Shouldn't be a * problem, but people may be confused as to why points are so * much faster in this demo... And why cva doesn't help them... */ glBegin( GL_POINTS ); for ( i = 0 ; i < numuniq ; i++ ) { glNormal3fv( &compressed_data[i][3] ); glVertex3fv( &compressed_data[i][0] ); } glEnd(); break; case (GLVERTEX|STRIPS): if (with_state & MATERIALS) { glBegin( GL_TRIANGLE_STRIP ); for (i=0;i<numverts;i++) { if (i % 600 == 0 && i != 0) { unsigned j = i / 600; glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, col[j]); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, col[j]); } glNormal3fv( &data[i][3] ); glVertex3fv( &data[i][0] ); } glEnd(); } else { glBegin( GL_TRIANGLE_STRIP ); for (i=0;i<numverts;i++) { glNormal3fv( &data[i][3] ); glVertex3fv( &data[i][0] ); } glEnd(); } break; default: fprintf(stderr, "unimplemented mode %x...\n", (with_state & (RENDER_STYLE_MASK|PRIMITIVE_MASK))); break; } }
int loadObject(const char* filename) { std::vector<std::string*> coord; std::vector<coordinate*> vertex; std::vector<face*> faces; std::vector<coordinate*> normals; std::ifstream in(filename); if(!in.is_open()) { std::cout << "failed file open" << std::endl; return -1; } char buff[256]; while(!in.eof()) { in.getline(buff, 256); coord.push_back(new std::string(buff)); } for (int i = 0; i < coord.size(); i++) { if(coord[i]->c_str()[0] == '#') { continue; } else if(coord[i]->c_str()[0] == 'v' && coord[i]->c_str()[1] == ' ') { float tmpx , tmpy , tmpz; sscanf(coord[i]->c_str(), "v %f %f %f " , &tmpx , &tmpy , &tmpz); vertex.push_back(new coordinate(tmpx , tmpy , tmpz)); } else if(coord[i]->c_str()[0] == 'v' && coord[i]->c_str()[1] == 'n') { float tmpx , tmpy , tmpz; sscanf(coord[i]->c_str(), "vn %f %f %f " , &tmpx , &tmpy , &tmpz); normals.push_back(new coordinate(tmpx , tmpy , tmpz)); } else if(coord[i]->c_str()[0] == 'f') { int a , b , c , d , e; if(count(coord[i]->begin(), coord[i]->end() , ' ') == 3) { sscanf(coord[i]->c_str(), "f %d//%d %d//%d %d//%d " , &a , &b , &c , &b , &d , &b); faces.push_back(new face(b,a,c,d)); } else { sscanf(coord[i]->c_str(), "f %d//%d %d//%d %d//%d %d//%d" , &a , &b , &c , &b , &d , &b , &e , &b); faces.push_back(new face(b,a,c,d,e)); } } } //draw int num; num = glGenLists(1); glNewList(num, GL_COMPILE); for(int i=0; i<faces.size(); i++) { if(faces[i]->four) //if it's a quad draw a quad { glBegin(GL_QUADS); //basically all I do here, is use the facenum (so the number of the face) as an index for the normal, so the 1st normal owe to the first face //I subtract 1 because the index start from 0 in C++ glNormal3f(normals[faces[i]->facenum-1]->x,normals[faces[i]->facenum-1]->y,normals[faces[i]->facenum-1]->z); //draw the faces glVertex3f(vertex[faces[i]->faces[0]-1]->x,vertex[faces[i]->faces[0]-1]->y,vertex[faces[i]->faces[0]-1]->z); glVertex3f(vertex[faces[i]->faces[1]-1]->x,vertex[faces[i]->faces[1]-1]->y,vertex[faces[i]->faces[1]-1]->z); glVertex3f(vertex[faces[i]->faces[2]-1]->x,vertex[faces[i]->faces[2]-1]->y,vertex[faces[i]->faces[2]-1]->z); glVertex3f(vertex[faces[i]->faces[3]-1]->x,vertex[faces[i]->faces[3]-1]->y,vertex[faces[i]->faces[3]-1]->z); glEnd(); } else { glBegin(GL_TRIANGLES); glNormal3f(normals[faces[i]->facenum-1]->x,normals[faces[i]->facenum-1]->y,normals[faces[i]->facenum-1]->z); glVertex3f(vertex[faces[i]->faces[0]-1]->x,vertex[faces[i]->faces[0]-1]->y,vertex[faces[i]->faces[0]-1]->z); glVertex3f(vertex[faces[i]->faces[1]-1]->x,vertex[faces[i]->faces[1]-1]->y,vertex[faces[i]->faces[1]-1]->z); glVertex3f(vertex[faces[i]->faces[2]-1]->x,vertex[faces[i]->faces[2]-1]->y,vertex[faces[i]->faces[2]-1]->z); glEnd(); } } glEndList(); //delete vectors for (int i = 0; i < coord.size(); ++i) { delete coord[i]; } for (int i = 0; i < faces.size(); ++i) { delete faces[i]; } for (int i = 0; i < normals.size(); ++i) { delete normals[i]; } for (int i = 0; i < vertex.size(); ++i) { delete vertex[i]; } return num; }
GridEditor::DataItem::DataItem(void) :influenceSphereDisplayListId(glGenLists(1)), domainBoxDisplayListId(glGenLists(1)) { }
void BL_Texture::setTexEnv(BL_Material *mat, bool modulate) { if (modulate || !GLEW_ARB_texture_env_combine) { glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); return; } if (glIsList(mEnvState)) { glCallList(mEnvState); return; } if (!mEnvState) mEnvState = glGenLists(1); glNewList(mEnvState, GL_COMPILE_AND_EXECUTE); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB ); GLfloat blend_operand = GL_SRC_COLOR; GLfloat blend_operand_prev = GL_SRC_COLOR; GLfloat alphaOp = GL_SRC_ALPHA; GLenum combiner = GL_COMBINE_RGB_ARB; GLenum source0 = GL_SOURCE0_RGB_ARB; GLenum source1 = GL_SOURCE1_RGB_ARB; GLenum source2 = GL_SOURCE2_RGB_ARB; GLenum op0 = GL_OPERAND0_RGB_ARB; GLenum op1 = GL_OPERAND1_RGB_ARB; GLenum op2 = GL_OPERAND2_RGB_ARB; // switch to alpha combiners if ( mat->flag[mUnit] &TEXALPHA ) { combiner = GL_COMBINE_ALPHA_ARB; source0 = GL_SOURCE0_ALPHA_ARB; source1 = GL_SOURCE1_ALPHA_ARB; source2 = GL_SOURCE2_ALPHA_ARB; op0 = GL_OPERAND0_ALPHA_ARB; op1 = GL_OPERAND1_ALPHA_ARB; op2 = GL_OPERAND2_ALPHA_ARB; blend_operand = GL_SRC_ALPHA; blend_operand_prev = GL_SRC_ALPHA; // invert if (mat->flag[mUnit] &TEXNEG) { blend_operand_prev = GL_ONE_MINUS_SRC_ALPHA; blend_operand = GL_ONE_MINUS_SRC_ALPHA; } } else { if (mat->flag[mUnit] &TEXNEG) { blend_operand_prev=GL_ONE_MINUS_SRC_COLOR; blend_operand = GL_ONE_MINUS_SRC_COLOR; } } bool using_alpha = false; if (mat->flag[mUnit] &USEALPHA) { alphaOp = GL_ONE_MINUS_SRC_ALPHA; using_alpha=true; } else if (mat->flag[mUnit] &USENEGALPHA) { alphaOp = GL_SRC_ALPHA; using_alpha = true; } switch (mat->blend_mode[mUnit]) { case BLEND_MIX: { // ------------------------------ if (!using_alpha) { GLfloat base_col[4]; base_col[0] = base_col[1] = base_col[2] = 0.f; base_col[3] = 1.f-mat->color_blend[mUnit]; glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,base_col ); } glTexEnvf( GL_TEXTURE_ENV, combiner, GL_INTERPOLATE_ARB); glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB); glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev ); glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE ); glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand); if (!using_alpha) glTexEnvf( GL_TEXTURE_ENV, source2, GL_CONSTANT_ARB ); else glTexEnvf( GL_TEXTURE_ENV, source2, GL_TEXTURE ); glTexEnvf( GL_TEXTURE_ENV, op2, alphaOp); }break; case BLEND_MUL: { // ------------------------------ glTexEnvf( GL_TEXTURE_ENV, combiner, GL_MODULATE); glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB); glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev); glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE ); if (using_alpha) glTexEnvf( GL_TEXTURE_ENV, op1, alphaOp); else glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand); }break; case BLEND_ADD: { // ------------------------------ glTexEnvf( GL_TEXTURE_ENV, combiner, GL_ADD_SIGNED_ARB); glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB ); glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev ); glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE ); if (using_alpha) glTexEnvf( GL_TEXTURE_ENV, op1, alphaOp); else glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand); }break; case BLEND_SUB: { // ------------------------------ glTexEnvf( GL_TEXTURE_ENV, combiner, GL_SUBTRACT_ARB); glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB ); glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev ); glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE ); glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand); }break; case BLEND_SCR: { // ------------------------------ glTexEnvf( GL_TEXTURE_ENV, combiner, GL_ADD); glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB ); glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev ); glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE ); if (using_alpha) glTexEnvf( GL_TEXTURE_ENV, op1, alphaOp); else glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand); } break; } glTexEnvf( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0f); glEndList(); }
void initWorld () { int i, j; float x, y, z; unsigned int startex; unsigned int moontex; unsigned int moonglowtex; unsigned int sunsettex; unsigned char *tex; // Initialize cloud texture object even if clouds are not turned on. // Sunsets and shockwaves can also use cloud texture. glGenTextures (1, &cloudtex); glBindTexture (GL_TEXTURE_2D, cloudtex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); LOAD_TEXTURE (tex, cloudmap, cloudmap_compressedsize, cloudmap_size) gluBuild2DMipmaps (GL_TEXTURE_2D, 2, CLOUDTEXSIZE, CLOUDTEXSIZE, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, tex); FREE_TEXTURE (tex) // initialize star texture if (dStardensity) { unsigned char starmap[STARTEXSIZE][STARTEXSIZE][3]; for (i = 0; i < STARTEXSIZE; i++) { for (j = 0; j < STARTEXSIZE; j++) { starmap[i][j][0] = starmap[i][j][1] = starmap[i][j][2] = 0; } } int u, v; unsigned int rgb[3]; for (i = 0; i < (dStardensity * 20); i++) { u = rsRandi (STARTEXSIZE - 4) + 2; v = rsRandi (STARTEXSIZE - 4) + 2; rgb[0] = 220 + rsRandi (36); rgb[1] = 220 + rsRandi (36); rgb[2] = 220 + rsRandi (36); rgb[rsRandi (3)] = 255; starmap[u][v][0] = rgb[0]; starmap[u][v][1] = rgb[1]; starmap[u][v][2] = rgb[2]; switch (rsRandi (6)) { // different stars case 0: // small case 1: case 2: starmap[u][v][0] /= 2; starmap[u][v][1] /= 2; starmap[u][v][2] /= 2; starmap[u + 1][v][0] = starmap[u - 1][v][0] = starmap[u][v + 1][0] = starmap[u][v - 1][0] = rgb[0] / (3 + rsRandi (6)); starmap[u + 1][v][1] = starmap[u - 1][v][1] = starmap[u][v + 1][1] = starmap[u][v - 1][1] = rgb[1] / (3 + rsRandi (6)); starmap[u + 1][v][2] = starmap[u - 1][v][2] = starmap[u][v + 1][2] = starmap[u][v - 1][2] = rgb[2] / (3 + rsRandi (6)); break; case 3: // medium case 4: starmap[u + 1][v][0] = starmap[u - 1][v][0] = starmap[u][v + 1][0] = starmap[u][v - 1][0] = rgb[0] / 2; starmap[u + 1][v][1] = starmap[u - 1][v][1] = starmap[u][v + 1][1] = starmap[u][v - 1][1] = rgb[1] / 2; starmap[u + 1][v][2] = starmap[u - 1][v][2] = starmap[u][v + 1][2] = starmap[u][v - 1][2] = rgb[2] / 2; break; case 5: // large starmap[u + 1][v][0] = starmap[u - 1][v][0] = starmap[u][v + 1][0] = starmap[u][v - 1][0] = char (float (rgb[0]) * 0.75f); starmap[u + 1][v][1] = starmap[u - 1][v][1] = starmap[u][v + 1][1] = starmap[u][v - 1][1] = char (float (rgb[1]) * 0.75f); starmap[u + 1][v][2] = starmap[u - 1][v][2] = starmap[u][v + 1][2] = starmap[u][v - 1][2] = char (float (rgb[2]) * 0.75f); starmap[u + 1][v + 1][0] = starmap[u + 1][v - 1][0] = starmap[u - 1][v + 1][0] = starmap[u - 1][v - 1][0] = rgb[0] / 4; starmap[u + 1][v + 1][1] = starmap[u + 1][v - 1][1] = starmap[u - 1][v + 1][1] = starmap[u - 1][v - 1][1] = rgb[1] / 4; starmap[u + 1][v + 1][2] = starmap[u + 1][v - 1][2] = starmap[u - 1][v + 1][2] = starmap[u - 1][v - 1][2] = rgb[2] / 4; } } glGenTextures (1, &startex); glBindTexture (GL_TEXTURE_2D, startex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); gluBuild2DMipmaps (GL_TEXTURE_2D, 3, STARTEXSIZE, STARTEXSIZE, GL_RGB, GL_UNSIGNED_BYTE, starmap); } //initialize moon texture if (dMoon) { unsigned char moonmap[MOONTEXSIZE][MOONTEXSIZE][4]; unsigned char *mtint; unsigned char *malpha; LOAD_TEXTURE (mtint, moontint, moontint_compressedsize, moontint_size) LOAD_TEXTURE (malpha, moonalpha, moonalpha_compressedsize, moonalpha_size) for (i = 0; i < MOONTEXSIZE; i++) { for (j = 0; j < MOONTEXSIZE; j++) { moonmap[i][j][0] = moonmap[i][j][1] = moonmap[i][j][2] = mtint[i * MOONTEXSIZE + j]; moonmap[i][j][3] = malpha[i * MOONTEXSIZE + j]; } } FREE_TEXTURE (mtint) FREE_TEXTURE (malpha) glGenTextures (1, &moontex); glBindTexture (GL_TEXTURE_2D, moontex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); gluBuild2DMipmaps (GL_TEXTURE_2D, 4, MOONTEXSIZE, MOONTEXSIZE, GL_RGBA, GL_UNSIGNED_BYTE, moonmap); } //initialize moon glow texture if (dMoonglow) { unsigned char moonglowmap[MOONGLOWTEXSIZE][MOONGLOWTEXSIZE][4]; float temp1, temp2, temp3, u, v; for (i = 0; i < MOONGLOWTEXSIZE; i++) { for (j = 0; j < MOONGLOWTEXSIZE; j++) { u = float (i - MOONGLOWTEXSIZE / 2) / float (MOONGLOWTEXSIZE / 2); v = float (j - MOONGLOWTEXSIZE / 2) / float (MOONGLOWTEXSIZE / 2); temp1 = 4.0f * ((u * u) + (v * v)) * (1.0f - ((u * u) + (v * v))); if (temp1 > 1.0f) temp1 = 1.0f; if (temp1 < 0.0f) temp1 = 0.0f; temp1 = temp1 * temp1 * temp1 * temp1; u *= 1.2f; v *= 1.2f; temp2 = 4.0f * ((u * u) + (v * v)) * (1.0f - ((u * u) + (v * v))); if (temp2 > 1.0f) temp2 = 1.0f; if (temp2 < 0.0f) temp2 = 0.0f; temp2 = temp2 * temp2 * temp2 * temp2; u *= 1.25f; v *= 1.25f; temp3 = 4.0f * ((u * u) + (v * v)) * (1.0f - ((u * u) + (v * v))); if (temp3 > 1.0f) temp3 = 1.0f; if (temp3 < 0.0f) temp3 = 0.0f; temp3 = temp3 * temp3 * temp3 * temp3; moonglowmap[i][j][0] = char (255.0f * (temp1 * 0.4f + temp2 * 0.4f + temp3 * 0.48f)); moonglowmap[i][j][1] = char (255.0f * (temp1 * 0.4f + temp2 * 0.48f + temp3 * 0.38f)); moonglowmap[i][j][2] = char (255.0f * (temp1 * 0.48f + temp2 * 0.4f + temp3 * 0.38f)); moonglowmap[i][j][3] = char (255.0f * (temp1 * 0.48f + temp2 * 0.48f + temp3 * 0.48f)); } } glGenTextures (1, &moonglowtex); glBindTexture (GL_TEXTURE_2D, moonglowtex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); gluBuild2DMipmaps (GL_TEXTURE_2D, 4, MOONGLOWTEXSIZE, MOONGLOWTEXSIZE, GL_RGBA, GL_UNSIGNED_BYTE, moonglowmap); } // do a sunset? doSunset = 1; if (!rsRandi (4)) doSunset = 0; // initialize sunset texture if (doSunset) { unsigned char *sunsetmap; unsigned char rgb[3]; float temp; sunsetmap = (unsigned char *)malloc (CLOUDTEXSIZE * CLOUDTEXSIZE * 3); if (rsRandi (3)) rgb[0] = 60 + rsRandi (42); else rgb[0] = rsRandi (102); rgb[1] = rsRandi (rgb[0]); rgb[2] = 0; if (rgb[1] < 50) rgb[2] = 100 - rsRandi (rgb[0]); for (j = 0; j < CLOUDTEXSIZE; j++) { for (i = 0; i < CLOUDTEXSIZE; i++) { sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 0] = rgb[0]; sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 1] = rgb[1]; sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 2] = rgb[2]; } } // clouds in sunset if (rsRandi (3)) { float cloudinf; // influence of clouds int xoffset = rsRandi (CLOUDTEXSIZE); int yoffset = rsRandi (CLOUDTEXSIZE); int x, y; for (i = 0; i < CLOUDTEXSIZE; i++) { for (j = 0; j < CLOUDTEXSIZE; j++) { x = (i + xoffset) % CLOUDTEXSIZE; y = (j + yoffset) % CLOUDTEXSIZE; cloudinf = float (cloudmap[x * CLOUDTEXSIZE * 2 + y * 2 + 1]) / 256.0f; temp = float (sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 0]) / 256.0f; temp *= cloudinf; sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 0] = char (temp * 256.0f); cloudinf *= float (cloudmap[x * CLOUDTEXSIZE * 2 + y * 2]) / 256.0f; temp = float (sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 1]) / 256.0f; temp *= cloudinf; sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 1] = char (temp * 256.0f); } } } // Fractal mountain generation int mountains[CLOUDTEXSIZE + 1]; mountains[0] = mountains[CLOUDTEXSIZE] = rsRandi (10) + 5; makeHeights (0, CLOUDTEXSIZE, mountains); for (i = 0; i < CLOUDTEXSIZE; i++) { for (j = 0; j <= mountains[i]; j++) { sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 0] = 0; sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 1] = 0; sunsetmap[i * CLOUDTEXSIZE * 3 + j * 3 + 2] = 0; } sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 1) * 3 + 0] /= 4; sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 1) * 3 + 1] /= 4; sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 1) * 3 + 2] /= 4; sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 2) * 3 + 0] /= 2; sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 2) * 3 + 1] /= 2; sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 2) * 3 + 2] /= 2; sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 3) * 3 + 0] = char (float (sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 3) * 3 + 0]) * 0.75f); sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 3) * 3 + 1] = char (float (sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 3) * 3 + 1]) * 0.75f); sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 3) * 3 + 2] = char (float (sunsetmap[i * CLOUDTEXSIZE * 3 + (mountains[i] + 3) * 3 + 2]) * 0.75f); } // build texture object glGenTextures (1, &sunsettex); glBindTexture (GL_TEXTURE_2D, sunsettex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); gluBuild2DMipmaps (GL_TEXTURE_2D, 3, CLOUDTEXSIZE, CLOUDTEXSIZE, GL_RGB, GL_UNSIGNED_BYTE, sunsetmap); free (sunsetmap); } //initialize earth texture if (dEarth) { glGenTextures (1, &earthneartex); glBindTexture (GL_TEXTURE_2D, earthneartex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); LOAD_TEXTURE (tex, earthnearmap, earthnearmap_compressedsize, earthnearmap_size) gluBuild2DMipmaps (GL_TEXTURE_2D, 3, EARTHNEARSIZE, EARTHNEARSIZE, GL_RGB, GL_UNSIGNED_BYTE, tex); FREE_TEXTURE (tex) glGenTextures (1, &earthfartex); glBindTexture (GL_TEXTURE_2D, earthfartex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); LOAD_TEXTURE (tex, earthfarmap, earthfarmap_compressedsize, earthfarmap_size) gluBuild2DMipmaps (GL_TEXTURE_2D, 3, EARTHFARSIZE, EARTHFARSIZE, GL_RGB, GL_UNSIGNED_BYTE, tex); FREE_TEXTURE (tex) glGenTextures (1, &earthlighttex); glBindTexture (GL_TEXTURE_2D, earthlighttex); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); LOAD_TEXTURE (tex, earthlightmap, earthlightmap_compressedsize, earthlightmap_size) gluBuild2DMipmaps (GL_TEXTURE_2D, 3, EARTHFARSIZE, EARTHFARSIZE, GL_RGB, GL_UNSIGNED_BYTE, tex); FREE_TEXTURE (tex) } // initialize star geometry if (dStardensity) { float stars[STARMESH + 1][STARMESH / 2][6]; // 6 = x,y,z,u,v,bright for (j = 0; j < STARMESH / 2; j++) { y = sin (RS_PIo2 * float (j) / float (STARMESH / 2)); for (i = 0; i <= STARMESH; i++) { x = cos (RS_PIx2 * float (i) / float (STARMESH)) * cos (RS_PIo2 * float (j) / float (STARMESH / 2)); z = sin (RS_PIx2 * float (i) / float (STARMESH)) * cos (RS_PIo2 * float (j) / float (STARMESH / 2)); // positions stars[i][j][0] = x * 20000.0f; stars[i][j][1] = 1500.0f + 18500.0f * y; stars[i][j][2] = z * 20000.0f; // tex coords stars[i][j][3] = 1.2f * x * (2.5f - y); stars[i][j][4] = 1.2f * z * (2.5f - y); // brightness if (stars[i][j][1] < 1501.0f) stars[i][j][5] = 0.0f; else stars[i][j][5] = 1.0f; } } starlist = glGenLists (1); glNewList (starlist, GL_COMPILE); glBindTexture (GL_TEXTURE_2D, startex); for (j = 0; j < (STARMESH / 2 - 1); j++) { glBegin (GL_TRIANGLE_STRIP); for (i = 0; i <= STARMESH; i++) { glColor3f (stars[i][j + 1][5], stars[i][j + 1][5], stars[i][j + 1][5]); glTexCoord2f (stars[i][j + 1][3], stars[i][j + 1][4]); glVertex3fv (stars[i][j + 1]); glColor3f (stars[i][j][5], stars[i][j][5], stars[i][j][5]); glTexCoord2f (stars[i][j][3], stars[i][j][4]); glVertex3fv (stars[i][j]); } glEnd (); } j = STARMESH / 2 - 1; glBegin (GL_TRIANGLE_FAN); glColor3f (1.0f, 1.0f, 1.0f); glTexCoord2f (0.0f, 0.0f); glVertex3f (0.0f, 20000.0f, 0.0f); for (i = 0; i <= STARMESH; i++) { glColor3f (stars[i][j][5], stars[i][j][5], stars[i][j][5]); glTexCoord2f (stars[i][j][3], stars[i][j][4]); glVertex3fv (stars[i][j]); } glEnd (); glEndList (); } // initialize moon geometry if (dMoon) { moonlist = glGenLists (1); glNewList (moonlist, GL_COMPILE); glColor4f (1.0f, 1.0f, 1.0f, 1.0f); glBindTexture (GL_TEXTURE_2D, moontex); glBegin (GL_TRIANGLE_STRIP); glTexCoord2f (0.0f, 0.0f); glVertex3f (-800.0f, -800.0f, 0.0f); glTexCoord2f (1.0f, 0.0f); glVertex3f (800.0f, -800.0f, 0.0f); glTexCoord2f (0.0f, 1.0f); glVertex3f (-800.0f, 800.0f, 0.0f); glTexCoord2f (1.0f, 1.0f); glVertex3f (800.0f, 800.0f, 0.0f); glEnd (); glEndList (); } // initialize moon glow geometry if (dMoonglow) { moonglowlist = glGenLists (1); glNewList (moonglowlist, GL_COMPILE); glBindTexture (GL_TEXTURE_2D, moonglowtex); glBegin (GL_TRIANGLE_STRIP); glTexCoord2f (0.0f, 0.0f); glVertex3f (-7000.0f, -7000.0f, 0.0f); glTexCoord2f (1.0f, 0.0f); glVertex3f (7000.0f, -7000.0f, 0.0f); glTexCoord2f (0.0f, 1.0f); glVertex3f (-7000.0f, 7000.0f, 0.0f); glTexCoord2f (1.0f, 1.0f); glVertex3f (7000.0f, 7000.0f, 0.0f); glEnd (); glEndList (); } // initialize cloud geometry if (dClouds) { for (j = 0; j <= CLOUDMESH; j++) { for (i = 0; i <= CLOUDMESH; i++) { x = float (i - (CLOUDMESH / 2)); z = float (j - (CLOUDMESH / 2)); clouds[i][j][0] = x * (40000.0f / float (CLOUDMESH)); clouds[i][j][2] = z * (40000.0f / float (CLOUDMESH)); x = float (fabs (x / float (CLOUDMESH / 2))); z = float (fabs (z / float (CLOUDMESH / 2))); clouds[i][j][1] = 2000.0f - 1000.0f * float (x * x + z * z); clouds[i][j][3] = float (-i) / float (CLOUDMESH / 6); // tex coords clouds[i][j][4] = float (-j) / float (CLOUDMESH / 6); clouds[i][j][5] = (clouds[i][j][1] - 1000.0f) * 0.00001f * float (dAmbient); // brightness if (clouds[i][j][5] < 0.0f) clouds[i][j][5] = 0.0f; } } } // initialize sunset geometry if (doSunset) { sunsetlist = glGenLists (1); float vert[6] = { 0.0f, 7654.0f, 8000.0f, 14142.0f, 18448.0f, 20000.0f }; glNewList (sunsetlist, GL_COMPILE); glBindTexture (GL_TEXTURE_2D, sunsettex); glBegin (GL_TRIANGLE_STRIP); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.0f); glVertex3f (vert[0], vert[2], vert[5]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (0.0f, 0.0f); glVertex3f (vert[0], vert[0], vert[5]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.125f); glVertex3f (-vert[1], vert[2], vert[4]); glColor3f (0.25f, 0.25f, 0.25f); glTexCoord2f (0.0f, 0.125f); glVertex3f (-vert[1], vert[0], vert[4]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.25f); glVertex3f (-vert[3], vert[2], vert[3]); glColor3f (0.5f, 0.5f, 0.5f); glTexCoord2f (0.0f, 0.25f); glVertex3f (-vert[3], vert[0], vert[3]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.375f); glVertex3f (-vert[4], vert[2], vert[1]); glColor3f (0.75f, 0.75f, 0.75f); glTexCoord2f (0.0f, 0.375f); glVertex3f (-vert[4], vert[0], vert[1]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.5f); glVertex3f (-vert[5], vert[2], vert[0]); glColor3f (1.0f, 1.0f, 1.0f); glTexCoord2f (0.0f, 0.5f); glVertex3f (-vert[5], vert[0], vert[0]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.625f); glVertex3f (-vert[4], vert[2], -vert[1]); glColor3f (0.75f, 0.75f, 0.75f); glTexCoord2f (0.0f, 0.625f); glVertex3f (-vert[4], vert[0], -vert[1]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.75f); glVertex3f (-vert[3], vert[2], -vert[3]); glColor3f (0.5f, 0.5f, 0.5f); glTexCoord2f (0.0f, 0.75f); glVertex3f (-vert[3], vert[0], -vert[3]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 0.875f); glVertex3f (-vert[1], vert[2], -vert[4]); glColor3f (0.25f, 0.25f, 0.25f); glTexCoord2f (0.0f, 0.875f); glVertex3f (-vert[1], vert[0], -vert[4]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (1.0f, 1.0f); glVertex3f (vert[0], vert[2], -vert[5]); glColor3f (0.0f, 0.0f, 0.0f); glTexCoord2f (0.0f, 1.0f); glVertex3f (vert[0], vert[0], -vert[5]); glEnd (); glEndList (); } // initialize earth geometry if (dEarth) { earthlist = glGenLists (1); earthnearlist = glGenLists (1); earthfarlist = glGenLists (1); float lit[] = { float (dAmbient) * 0.01f, float (dAmbient) * 0.01f, float (dAmbient) * 0.01f }; float unlit[] = { 0.0f, 0.0f, 0.0f }; float vert[2] = { 839.68f, 8396.8f }; float tex[4] = { 0.0f, 0.45f, 0.55f, 1.0f }; glNewList (earthnearlist, GL_COMPILE); glColor3fv (lit); glBegin (GL_TRIANGLE_STRIP); glTexCoord2f (tex[0], tex[0]); glVertex3f (-vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[0], tex[3]); glVertex3f (-vert[0], 0.0f, vert[0]); glTexCoord2f (tex[3], tex[0]); glVertex3f (vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[3], tex[3]); glVertex3f (vert[0], 0.0f, vert[0]); glEnd (); glEndList (); glNewList (earthfarlist, GL_COMPILE); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[1], tex[1]); glVertex3f (-vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[2], tex[1]); glVertex3f (vert[0], 0.0f, -vert[0]); glColor3fv (unlit); glTexCoord2f (tex[0], tex[0]); glVertex3f (-vert[1], 0.0f, -vert[1]); glTexCoord2f (tex[3], tex[0]); glVertex3f (vert[1], 0.0f, -vert[1]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[1], tex[2]); glVertex3f (-vert[0], 0.0f, vert[0]); glTexCoord2f (tex[1], tex[1]); glVertex3f (-vert[0], 0.0f, -vert[0]); glColor3fv (unlit); glTexCoord2f (tex[0], tex[3]); glVertex3f (-vert[1], 0.0f, vert[1]); glTexCoord2f (tex[0], tex[0]); glVertex3f (-vert[1], 0.0f, -vert[1]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[2], tex[2]); glVertex3f (vert[0], 0.0f, vert[0]); glTexCoord2f (tex[1], tex[2]); glVertex3f (-vert[0], 0.0f, vert[0]); glColor3fv (unlit); glTexCoord2f (tex[3], tex[3]); glVertex3f (vert[1], 0.0f, vert[1]); glTexCoord2f (tex[0], tex[3]); glVertex3f (-vert[1], 0.0f, vert[1]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[2], tex[1]); glVertex3f (vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[2], tex[2]); glVertex3f (vert[0], 0.0f, vert[0]); glColor3fv (unlit); glTexCoord2f (tex[3], tex[0]); glVertex3f (vert[1], 0.0f, -vert[1]); glTexCoord2f (tex[3], tex[3]); glVertex3f (vert[1], 0.0f, vert[1]); glEnd (); glEndList (); glNewList (earthlist, GL_COMPILE); lit[0] = lit[1] = lit[2] = 0.4f; glColor3fv (lit); glBegin (GL_TRIANGLE_STRIP); glTexCoord2f (tex[1], tex[1]); glVertex3f (-vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[1], tex[2]); glVertex3f (-vert[0], 0.0f, vert[0]); glTexCoord2f (tex[2], tex[1]); glVertex3f (vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[2], tex[2]); glVertex3f (vert[0], 0.0f, vert[0]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[1], tex[1]); glVertex3f (-vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[2], tex[1]); glVertex3f (vert[0], 0.0f, -vert[0]); glColor3fv (unlit); glTexCoord2f (tex[0], tex[0]); glVertex3f (-vert[1], 0.0f, -vert[1]); glTexCoord2f (tex[3], tex[0]); glVertex3f (vert[1], 0.0f, -vert[1]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[1], tex[2]); glVertex3f (-vert[0], 0.0f, vert[0]); glTexCoord2f (tex[1], tex[1]); glVertex3f (-vert[0], 0.0f, -vert[0]); glColor3fv (unlit); glTexCoord2f (tex[0], tex[3]); glVertex3f (-vert[1], 0.0f, vert[1]); glTexCoord2f (tex[0], tex[0]); glVertex3f (-vert[1], 0.0f, -vert[1]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[2], tex[2]); glVertex3f (vert[0], 0.0f, vert[0]); glTexCoord2f (tex[1], tex[2]); glVertex3f (-vert[0], 0.0f, vert[0]); glColor3fv (unlit); glTexCoord2f (tex[3], tex[3]); glVertex3f (vert[1], 0.0f, vert[1]); glTexCoord2f (tex[0], tex[3]); glVertex3f (-vert[1], 0.0f, vert[1]); glEnd (); glBegin (GL_TRIANGLE_STRIP); glColor3fv (lit); glTexCoord2f (tex[2], tex[1]); glVertex3f (vert[0], 0.0f, -vert[0]); glTexCoord2f (tex[2], tex[2]); glVertex3f (vert[0], 0.0f, vert[0]); glColor3fv (unlit); glTexCoord2f (tex[3], tex[0]); glVertex3f (vert[1], 0.0f, -vert[1]); glTexCoord2f (tex[3], tex[3]); glVertex3f (vert[1], 0.0f, vert[1]); glEnd (); glEndList (); } }
void ccOctree::RenderOctreeAs( CC_OCTREE_DISPLAY_TYPE octreeDisplayType, CCLib::DgmOctree* theOctree, unsigned char level, ccGenericPointCloud* theAssociatedCloud, int &octreeGLListID, bool updateOctreeGLDisplay) { if (!theOctree || !theAssociatedCloud) return; glPushAttrib(GL_LIGHTING_BIT); if (octreeDisplayType==WIRE) { //cet affichage demande trop de memoire pour le stocker sous forme de liste OpenGL //donc on doit le generer dynamiquement glDisable(GL_LIGHTING); //au cas où la lumiere soit allumee glColor3ubv(ccColor::green); theOctree->executeFunctionForAllCellsAtLevel(level,&DrawCellAsABox,NULL); } else { glDrawParams glParams; theAssociatedCloud->getDrawingParameters(glParams); if (glParams.showNorms) { //DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version is sometimes 1.0! glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, CC_DEFAULT_CLOUD_AMBIENT_COLOR ); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, CC_DEFAULT_CLOUD_SPECULAR_COLOR ); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, CC_DEFAULT_CLOUD_DIFFUSE_COLOR ); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, CC_DEFAULT_CLOUD_EMISSION_COLOR ); glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, CC_DEFAULT_CLOUD_SHININESS); glEnable(GL_LIGHTING); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE); } if (!glParams.showColors) glColor3ubv(ccColor::white); if (updateOctreeGLDisplay || octreeGLListID<0) { if (octreeGLListID<0) octreeGLListID = glGenLists(1); else if (glIsList(octreeGLListID)) glDeleteLists(octreeGLListID,1); glNewList(octreeGLListID,GL_COMPILE); if (octreeDisplayType == MEAN_POINTS) { void* additionalParameters[2] = { (void*)&glParams, (void*)theAssociatedCloud, }; glBegin(GL_POINTS); theOctree->executeFunctionForAllCellsAtLevel(level,&DrawCellAsAPoint,additionalParameters,0,"Render octree"); glEnd(); } else { //by default we use a box as primitive PointCoordinateType cs = theOctree->getCellSize(level); CCVector3 dims(cs,cs,cs); ccBox box(dims); box.showColors(glParams.showColors || glParams.showSF); box.showNormals(glParams.showNorms); //trick: replace all normal indexes so that they point on the first one { if (box.arePerTriangleNormalsEnabled()) for (unsigned i=0;i<box.size();++i) box.setTriangleNormalIndexes(i,0,0,0); } //fake context CC_DRAW_CONTEXT context; context.flags = CC_DRAW_3D | CC_DRAW_FOREGROUND| CC_LIGHT_ENABLED; context._win = 0; void* additionalParameters[4] = { (void*)&glParams, (void*)theAssociatedCloud, (void*)&box, (void*)&context }; theOctree->executeFunctionForAllCellsAtLevel(level,&DrawCellAsAPrimitive,additionalParameters,0); } glEndList(); } glCallList(octreeGLListID); if (glParams.showNorms) { glDisable(GL_COLOR_MATERIAL); glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE)); glDisable(GL_LIGHTING); } } glPopAttrib(); }
void init_torpedo(void) { static const float emit0[] = {1.0, 1.0, 1.0, 1.0}; /* torp material properties */ static const float ad0[] = {0.0, 0.0, 0.0, 1.0}; static const float emit1[] = {1.0, 1.0, 1.0, 1.0}; static const float ad1[] = {0.0, 0.0, 0.0, 0.4}; static const float emit2[] = {0.0, 0.6, 1.0, 1.0}; static const float ad2[] = {0.0, 0.0, 0.0, 0.3}; static const float emit_off[] = {0.0 , 0.0, 0.0, 1.0}; static const float diffuse[] = {0.0, 0.6, 1.0, 1.0}; /* tracer light property */ int i, k; torps_in_flight_flag = 0; tracer_light_flag = 0; memset(torp, 0, sizeof(torp)); for (i = 0; i < MAX_TORPS; ++i) { torp[i].ttl = TORP_TTL * tps; torp[i].trail_num = NO_TRAIL; } /* set up torpedo display list */ torp_dl = glGenLists(1); glNewList(torp_dl, GL_COMPILE); glShadeModel(GL_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ad0); glMaterialfv(GL_FRONT, GL_EMISSION, emit0); glutSolidSphere(TORP_RADIUS - 2 * TORP_RADIUS_DELTA, 10, 10); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ad1); glMaterialfv(GL_FRONT, GL_EMISSION, emit1); glutSolidSphere(TORP_RADIUS - TORP_RADIUS_DELTA, 10, 10); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ad2); glMaterialfv(GL_FRONT, GL_EMISSION, emit2) ; glutSolidSphere(TORP_RADIUS + TORP_RADIUS_DELTA, 10, 10); glMaterialfv(GL_FRONT, GL_EMISSION, emit_off); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, emit_off); glDisable(GL_BLEND); glEndList(); /* set up the torpedo billboard */ k = 3; /* scaling factor */ torp_billboard_dl = glGenLists(1); glNewList(torp_billboard_dl, GL_COMPILE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBegin(GL_QUADS); glTexCoord2f(1, 0); glVertex3f(k / 2, -k / 2, 0); glTexCoord2f(1, 1); glVertex3f(k / 2, k / 2, 0); glTexCoord2f(0, 1); glVertex3f(-k / 2, k / 2, 0); glTexCoord2f(0, 0); glVertex3f(-k / 2, -k / 2, 0); glEnd(); glDisable(GL_BLEND); glEndList(); /* set up tracer torpedo light properties */ glLightfv(GL_LIGHT2, GL_DIFFUSE, diffuse); glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 50); return; }
TestScene(int argc, char **argv, int n_dlist) : Scene(argc, argv) { draw_list_base = glGenLists(n_dlist); draw_flags.resize(n_dlist, false); }
void LoadAsc(GLuint *list,char *file) { FILE *fp; GLfloat p[MAX_VERTS][3]; GLfloat normal[MAX_VERTS][3]; float ncount[MAX_VERTS]; int v[MAX_TRIS][3]; char line[MAX_LEN]; char *s; int i,j; int verts,faces; GLuint v0,v1,v2; GLfloat n[3]; GLfloat len,k; GLfloat min[3]={MAX_F,MAX_F,MAX_F}; GLfloat max[3]={-MAX_F,-MAX_F,-MAX_F}; char *coord_str[]={"X","Z","Y"}; fp=fopen(file,"r"); if (!fp) { printf("Can't open %s!\n",file); exit(1); } while (strncmp(fgets(line,MAX_LEN,fp),"Tri-mesh",8)) ; s=strstr(line,":")+1; verts=atoi(s); s=strstr(s,":")+1; faces=atoi(s); if (verts>MAX_VERTS) { printf("Too many vertices..\n"); exit(1); } while (strncmp(fgets(line,MAX_LEN,fp),"Vertex list",11)) ; for (i=0;i<verts;i++) { while (strncmp(fgets(line,MAX_LEN,fp),"Vertex",6)) ; for (j=0;j<3;j++) { s=strstr(line,coord_str[j])+2; k=atoi(s); if (k>max[j]) max[j]=k; if (k<min[j]) min[j]=k; p[i][j]=k; } } len=0; for (i=0;i<3;i++) { k=max[i]-min[i]; if (k>len) {len=k;j=i;} n[i]=(max[i]+min[i])/2; } len/=2; for (i=0;i<verts;i++) { for (j=0;j<3;j++) { p[i][j]-=n[j]; p[i][j]/=len; } } *list=glGenLists(1); glNewList(*list,GL_COMPILE); glBegin(GL_TRIANGLES); memset(ncount,0,sizeof(ncount)); memset(normal,0,sizeof(normal)); while (strncmp(fgets(line,MAX_LEN,fp),"Face list",9)) ; for (i=0;i<faces;i++) { while (strncmp(fgets(line,MAX_LEN,fp),"Face",4)) ; s=strstr(line,"A")+2; v0=v[i][0]=atoi(s); s=strstr(line,"B")+2; v1=v[i][1]=atoi(s); s=strstr(line,"C")+2; v2=v[i][2]=atoi(s); n[0]=((p[v1][1]-p[v0][1])*(p[v2][2]-p[v0][2]) - (p[v1][2]-p[v0][2])*(p[v2][1]-p[v0][1])); n[1]=((p[v1][2]-p[v0][2])*(p[v2][0]-p[v0][0]) - (p[v1][0]-p[v0][0])*(p[v2][2]-p[v0][2])); n[2]=((p[v1][0]-p[v0][0])*(p[v2][1]-p[v0][1]) - (p[v1][1]-p[v0][1])*(p[v2][0]-p[v0][0])); len=n[0]*n[0]+n[1]*n[1]+n[2]*n[2]; len=sqrt(len); n[0]/=len; n[1]/=len; n[2]/=len; #ifdef SMOOTH_NORMALS for (j=0;j<3;j++){ normal[v[i][j]][0]+=n[0]; normal[v[i][j]][1]+=n[1]; normal[v[i][j]][2]+=n[2]; ncount[v[i][j]]++; } #else glNormal3fv(n); for (j=0;j<3;j++) glVertex3fv(p[v[i][j]]); #endif } #ifdef SMOOTH_NORMALS for (i=0;i<verts;i++) { for (j=0;j<3;j++) { normal[i][j]/=ncount[i]; } } for (i=0;i<faces;i++) { for (j=0;j<3;j++) { glNormal3f(normal[v[i][j]][0], normal[v[i][j]][1], normal[v[i][j]][2]); glVertex3fv(p[v[i][j]]); } } #endif glEnd(); glEndList(); fclose(fp); }
/* metric map: use linear interpolation on values rather than color interpolation ! */ GLuint listTriaMap(pScene sc,pMesh mesh) { pMaterial pm; pTriangle pt; pPoint p0,p1,p2; pSolution ps0,ps1,ps2; GLint dlist; double ax,ay,az,bx,by,bz,dd; float cx,cy,cz,n[3]; int k,m,is0,is1,is2; triangle t; /* default */ if ( !mesh->nt ) return(0); if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) ) return(0); if ( ddebug ) printf("create display list map / TRIA\n"); /* build display list */ dlist = glGenLists(1); glNewList(dlist,GL_COMPILE); if ( glGetError() ) return(0); #ifdef IGL bool transp = sc->material->dif[3] < 0.999; int old_depth_func =0; glGetIntegerv(GL_DEPTH_FUNC,&old_depth_func); if ( transp ) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glDepthFunc(GL_ALWAYS); sc->igl_params->alpha_holder = sc->material->dif[3]; }else { sc->igl_params->alpha_holder = 1.0; } #endif /* build list */ for (m=0; m<sc->par.nbmat; m++) { pm = &sc->material[m]; k = pm->depmat[LTria]; if ( !k || pm->flag ) continue; if ( sc->type & S_FLAT ) { glBegin(GL_TRIANGLES); while ( k != 0 ) { pt = &mesh->tria[k]; if ( !pt->v[0] ) { k = pt->nxt; continue; } p0 = &mesh->point[pt->v[0]]; p1 = &mesh->point[pt->v[1]]; p2 = &mesh->point[pt->v[2]]; /* compute normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( dd > 0.0f ) { dd = 1.0f / sqrt(dd); n[0] *= dd; n[1] *= dd; n[2] *= dd; } memcpy(t.na,n,3*sizeof(float)); memcpy(t.nb,n,3*sizeof(float)); memcpy(t.nc,n,3*sizeof(float)); if ( sc->shrink < 1.0 ) { cx = (p0->c[0] + p1->c[0] + p2->c[0]) / 3.0; cy = (p0->c[1] + p1->c[1] + p2->c[1]) / 3.0; cz = (p0->c[2] + p1->c[2] + p2->c[2]) / 3.0; t.a[0] = sc->shrink*(p0->c[0]-cx)+cx; t.a[1] = sc->shrink*(p0->c[1]-cy)+cy; t.a[2] = sc->shrink*(p0->c[2]-cz)+cz; t.b[0] = sc->shrink*(p1->c[0]-cx)+cx; t.b[1] = sc->shrink*(p1->c[1]-cy)+cy; t.b[2] = sc->shrink*(p1->c[2]-cz)+cz; t.c[0] = sc->shrink*(p2->c[0]-cx)+cx; t.c[1] = sc->shrink*(p2->c[1]-cy)+cy; t.c[2] = sc->shrink*(p2->c[2]-cz)+cz; } else { t.a[0] = p0->c[0]; t.a[1] = p0->c[1]; t.a[2] = p0->c[2]; t.b[0] = p1->c[0]; t.b[1] = p1->c[1]; t.b[2] = p1->c[2]; t.c[0] = p2->c[0]; t.c[1] = p2->c[1]; t.c[2] = p2->c[2]; } if ( mesh->typage == 2 ) { ps0 = &mesh->sol[pt->v[0]]; ps1 = &mesh->sol[pt->v[1]]; ps2 = &mesh->sol[pt->v[2]]; t.va = ps0->bb; t.vb = ps1->bb; t.vc = ps2->bb; } else { ps0 = &mesh->sol[k]; t.va = t.vb = t.vc = ps0->bb; } #ifdef IGL if(pt->ref == 1) { // Self-intersection float red[4] = {1.0, 0.0, 0.0, 1.0}; red[3] = sc->material->dif[3]; glColor4fv(red); glNormal3fv(n); glVertex3fv(t.a); glColor4fv(red); glNormal3fv(n); glVertex3fv(t.b); glColor4fv(red); glNormal3fv(n); glVertex3fv(t.c); }else{ #endif cutTriangle(sc,t); #ifdef IGL } #endif k = pt->nxt; } glEnd(); } else { glBegin(GL_TRIANGLES); while ( k != 0 ) { pt = &mesh->tria[k]; if ( !pt->v[0] ) { k = pt->nxt; continue; } p0 = &mesh->point[pt->v[0]]; p1 = &mesh->point[pt->v[1]]; p2 = &mesh->point[pt->v[2]]; /* compute normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( dd > 0.0f ) { dd = 1.0f / sqrt(dd); n[0] *= dd; n[1] *= dd; n[2] *= dd; } is0 = is1 = is2 = 0; if ( mesh->extra->iv ) { if ( pt->v[0] <= mesh->nvn ) is0 = mesh->extra->nv[pt->v[0]]; if ( pt->v[1] <= mesh->nvn ) is1 = mesh->extra->nv[pt->v[1]]; if ( pt->v[2] <= mesh->nvn ) is2 = mesh->extra->nv[pt->v[2]]; } if ( !is0 && pt->v[0] <= mesh->extra->it ) is0 = mesh->extra->nt[3*(k-1)+1]; if ( !is1 && pt->v[1] <= mesh->extra->it ) is1 = mesh->extra->nt[3*(k-1)+2]; if ( !is2 && pt->v[2] <= mesh->extra->it ) is2 = mesh->extra->nt[3*(k-1)+3]; if ( sc->shrink < 1.0 ) { cx = (p0->c[0] + p1->c[0] + p2->c[0]) / 3.; cy = (p0->c[1] + p1->c[1] + p2->c[1]) / 3.; cz = (p0->c[2] + p1->c[2] + p2->c[2]) / 3.; t.a[0] = sc->shrink*(p0->c[0]-cx)+cx; t.a[1] = sc->shrink*(p0->c[1]-cy)+cy; t.a[2] = sc->shrink*(p0->c[2]-cz)+cz; t.b[0] = sc->shrink*(p1->c[0]-cx)+cx; t.b[1] = sc->shrink*(p1->c[1]-cy)+cy; t.b[2] = sc->shrink*(p1->c[2]-cz)+cz; t.c[0] = sc->shrink*(p2->c[0]-cx)+cx; t.c[1] = sc->shrink*(p2->c[1]-cy)+cy; t.c[2] = sc->shrink*(p2->c[2]-cz)+cz; } else { t.a[0] = p0->c[0]; t.a[1] = p0->c[1]; t.a[2] = p0->c[2]; t.b[0] = p1->c[0]; t.b[1] = p1->c[1]; t.b[2] = p1->c[2]; t.c[0] = p2->c[0]; t.c[1] = p2->c[1]; t.c[2] = p2->c[2]; } if ( !is0 ) memcpy(t.na,n,3*sizeof(float)); else { t.na[0] = mesh->extra->n[3*(is0-1)+1]; t.na[1] = mesh->extra->n[3*(is0-1)+2]; t.na[2] = mesh->extra->n[3*(is0-1)+3]; } if ( !is1 ) memcpy(t.nb,n,3*sizeof(float)); else { t.nb[0] = mesh->extra->n[3*(is1-1)+1]; t.nb[1] = mesh->extra->n[3*(is1-1)+2]; t.nb[2] = mesh->extra->n[3*(is1-1)+3]; } if ( !is2 ) memcpy(t.nc,n,3*sizeof(float)); else { t.nc[0] = mesh->extra->n[3*(is2-1)+1]; t.nc[1] = mesh->extra->n[3*(is2-1)+2]; t.nc[2] = mesh->extra->n[3*(is2-1)+3]; } if ( mesh->typage == 2 ) { ps0 = &mesh->sol[pt->v[0]]; ps1 = &mesh->sol[pt->v[1]]; ps2 = &mesh->sol[pt->v[2]]; t.va = ps0->bb; t.vb = ps1->bb; t.vc = ps2->bb; } else { ps0 = &mesh->sol[k]; t.va = t.vb = t.vc = ps0->bb; } cutTriangle(sc,t); k = pt->nxt; } glEnd(); } } #ifdef IGL if(transp) { glDepthFunc(old_depth_func); glDisable(GL_BLEND); } #endif glEndList(); return(dlist); }
void XMLScene::auxDrawObjects(vector<Node*> sons,pair<string,Appearance*> fatherAppearance) { //searches son position on vector unsigned int sonInd; vector<Node*> childrenIds; for (sonInd=0;sonInd<sons.size();sonInd++) { glPushMatrix(); childrenIds=sons[sonInd]->getChildNodes(); if(sons[sonInd]->getDisplayList()) { if(sons[sonInd]->getDisplayListInd()==-1) { if(childrenIds.size()>0) { if(sons[sonInd]->getNodeAppearance().first=="") { auxDrawObjects(childrenIds,fatherAppearance); } else auxDrawObjects(childrenIds,sons[sonInd]->getNodeAppearance()); } GLuint index = glGenLists(1); sons[sonInd]->setDisplayListInd(index); glNewList(index, GL_COMPILE); sons[sonInd]->draw(fatherAppearance.second); //if child is found if(childrenIds.size()>0) { if(sons[sonInd]->getNodeAppearance().first=="") { auxDrawObjects(childrenIds,fatherAppearance); } else auxDrawObjects(childrenIds,sons[sonInd]->getNodeAppearance()); } glEndList(); glPopMatrix(); glCallList(index); } else { glCallList(sons[sonInd]->getDisplayListInd()); glPopMatrix(); } } else { sons[sonInd]->draw(fatherAppearance.second); childrenIds=sons[sonInd]->getChildNodes(); //if child is found if(childrenIds.size()>0) { if(sons[sonInd]->getNodeAppearance().first=="") { auxDrawObjects(childrenIds,fatherAppearance); } else auxDrawObjects(childrenIds,sons[sonInd]->getNodeAppearance()); } glPopMatrix(); } } }
/* build list of tetrahedra */ GLuint listTetraMap(pScene sc,pMesh mesh,ubyte clip) { pMaterial pm; pTetra pt; pPoint p0,p1,p2; pSolution ps0,ps1,ps2; GLint dlist = 0; float cx,cy,cz,ax,ay,az,bx,by,bz,d,n[3]; int k,l,m; triangle t; /* default */ if ( !mesh->ntet ) return(0); if ( ddebug ) printf("create display list map / TETRA\n"); if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) ) return(0); // By Leo: get number of triangles to render tet colors correctly int boundary_faces = mesh->nt; /* build display list */ dlist = glGenLists(1); glNewList(dlist,GL_COMPILE); if ( glGetError() ) return(0); #ifdef IGL bool transp = sc->igl_params->tet_color[3] < 0.999; int old_depth_func =0; glGetIntegerv(GL_DEPTH_FUNC,&old_depth_func); if ( transp ) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glDepthFunc(GL_ALWAYS); sc->igl_params->alpha_holder = sc->igl_params->tet_color[3]; }else { sc->igl_params->alpha_holder = 1.0; } #endif /* build list */ for (m=0; m<sc->par.nbmat; m++) { pm = &sc->material[m]; k = pm->depmat[LTets]; if ( !k || pm->flag ) continue; glBegin(GL_TRIANGLES); while ( k != 0 ) { pt = &mesh->tetra[k]; if ( !pt->v[0] || (clip && !pt->clip) ) { k = pt->nxt; continue; } /* build 4 faces */ cx = cy = cz = 0.0f; for (l=0; l<4; l++) { p0 = &mesh->point[pt->v[l]]; cx += p0->c[0]; cy += p0->c[1]; cz += p0->c[2]; } cx /= 4.; cy /= 4.; cz /= 4.; for (l=0; l<4; l++) { p0 = &mesh->point[pt->v[ct[l][0]]]; p1 = &mesh->point[pt->v[ct[l][1]]]; p2 = &mesh->point[pt->v[ct[l][2]]]; /* compute face normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; d = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( d > 0.0f ) { d = 1.0f / sqrt(d); n[0] *= d; n[1] *= d; n[2] *= d; } /* store triangle */ t.a[0] = sc->shrink*(p0->c[0]-cx)+cx; t.a[1] = sc->shrink*(p0->c[1]-cy)+cy; t.a[2] = sc->shrink*(p0->c[2]-cz)+cz; t.b[0] = sc->shrink*(p1->c[0]-cx)+cx; t.b[1] = sc->shrink*(p1->c[1]-cy)+cy; t.b[2] = sc->shrink*(p1->c[2]-cz)+cz; t.c[0] = sc->shrink*(p2->c[0]-cx)+cx; t.c[1] = sc->shrink*(p2->c[1]-cy)+cy; t.c[2] = sc->shrink*(p2->c[2]-cz)+cz; /* store normals */ memcpy(t.na,n,3*sizeof(float)); memcpy(t.nb,n,3*sizeof(float)); memcpy(t.nc,n,3*sizeof(float)); if ( mesh->typage == 2 ) { /* solutions at vertices */ ps0 = &mesh->sol[pt->v[ct[l][0]]]; ps1 = &mesh->sol[pt->v[ct[l][1]]]; ps2 = &mesh->sol[pt->v[ct[l][2]]]; t.va = ps0->bb; t.vb = ps1->bb; t.vc = ps2->bb; } else { /* solution at element */ ps0 = &mesh->sol[k+boundary_faces]; t.va = t.vb = t.vc = ps0->bb; } /* color interpolation */ cutTriangle(sc,t); } k = pt->nxt; } glEnd(); } #ifdef IGL if(transp) { glDepthFunc(old_depth_func); glDisable(GL_BLEND); } #endif glEndList(); return(dlist); }
ENTRYPOINT void init_glblur (ModeInfo *mi) { glblur_configuration *bp; int wire = MI_IS_WIREFRAME(mi); MI_INIT (mi, bps); bp = &bps[MI_SCREEN(mi)]; bp->glx_context = init_GL(mi); reshape_glblur (mi, MI_WIDTH(mi), MI_HEIGHT(mi)); clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */ if (!wire) { GLfloat gamb[4]= {0.2, 0.2, 0.2, 1.0}; GLfloat pos[4] = {0.0, 5.0, 10.0, 1.0}; GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0}; GLfloat dif[4] = {0.3, 0.3, 0.3, 1.0}; GLfloat spc[4] = {0.8, 0.8, 0.8, 1.0}; GLfloat shiny = 128; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_NORMALIZE); glShadeModel(GL_SMOOTH); glLightModelfv (GL_LIGHT_MODEL_AMBIENT, gamb); glLightfv(GL_LIGHT0, GL_POSITION, pos); glLightfv(GL_LIGHT0, GL_AMBIENT, amb); glLightfv(GL_LIGHT0, GL_DIFFUSE, dif); glLightfv(GL_LIGHT0, GL_SPECULAR, spc); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glMaterialf(GL_FRONT, GL_SHININESS, shiny); } { Bool spinx=False, spiny=False, spinz=False; double spin_speed = 0.9; double wander_speed = 0.06; char *s = do_spin; while (*s) { if (*s == 'x' || *s == 'X') spinx = True; else if (*s == 'y' || *s == 'Y') spiny = True; else if (*s == 'z' || *s == 'Z') spinz = True; else if (*s == '0') ; else { fprintf (stderr, "%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n", progname, do_spin); exit (1); } s++; } bp->rot = make_rotator (spinx ? spin_speed : 0, spiny ? spin_speed : 0, spinz ? spin_speed : 0, 1.0, do_wander ? wander_speed : 0, False); bp->trackball = gltrackball_init (True); } if (blursize < 0) blursize = 0; if (blursize > 200) blursize = 200; bp->ncolors = 128; bp->colors0 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors1 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors2 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); bp->colors3 = (XColor *) calloc(bp->ncolors, sizeof(XColor)); make_smooth_colormap (0, 0, 0, bp->colors0, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors1, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors2, &bp->ncolors, False, 0, False); make_smooth_colormap (0, 0, 0, bp->colors3, &bp->ncolors, False, 0, False); bp->ccolor = 0; bp->obj_dlist0 = glGenLists (1); bp->obj_dlist1 = glGenLists (1); bp->obj_dlist2 = glGenLists (1); bp->obj_dlist3 = glGenLists (1); bp->scene_dlist1 = glGenLists (1); bp->scene_dlist2 = glGenLists (1); init_texture (mi); generate_object (mi); }
GLuint alt2dList(pScene sc,pMesh mesh,int geomtype,float shrink,float altcoef) { pTriangle pt,pt1; pMaterial pm; pQuad pq; pPoint p0,p1,p2,p3; pSolution ps0,ps1,ps2,ps3; GLuint dlist; double ax,ay,az,bx,by,bz,dd,kc,rgb[4]; float cx,cy,cz,n[3]; int *adj,k,m,ia,iadr; ubyte *voy; triangle t,t1,t2; static double hsv[3] = { 0.0, 1.0, 0.80 }; static float nn[3] = {1.0, 0.0, 0.0 }; /* default */ if ( ddebug ) printf("create 2d elevation map list\n"); if ( geomtype == LTria && !mesh->nt ) return(0); if ( geomtype == LQuad && !mesh->nq ) return(0); if ( egal(sc->iso.val[0],sc->iso.val[MAXISO-1]) ) return(0); /* build display list */ dlist = glGenLists(1); glNewList(dlist,GL_COMPILE); if ( glGetError() ) return(0); mesh->zmin = altcoef*mesh->bbmin; mesh->zmax = altcoef*mesh->bbmax; if ( mesh->bbmin*mesh->bbmax < 0.0 ) { mesh->ztra = mesh->zmin; } else { mesh->ztra = 0.95 * mesh->zmin; } switch (geomtype) { case LTria: if ( ddebug ) printf("create triangle list %d\n",mesh->nt); if ( mesh->typage == 1 ) { if ( mesh->nt && !hashTria(mesh) ) return(0); } glBegin(GL_TRIANGLES); for (m=0; m<sc->par.nbmat; m++) { pm = &sc->material[m]; k = pm->depmat[LTria]; if ( !k || pm->flag ) continue; while ( k != 0 ) { pt = &mesh->tria[k]; if ( !pt->v[0] ) { k = pt->nxt; continue; } p0 = &mesh->point[pt->v[0]]; p1 = &mesh->point[pt->v[1]]; p2 = &mesh->point[pt->v[2]]; if ( mesh->typage == 1 ) ps0 = ps1 = ps2 = &mesh->sol[k]; else { ps0 = &mesh->sol[pt->v[0]]; ps1 = &mesh->sol[pt->v[1]]; ps2 = &mesh->sol[pt->v[2]]; } cx = (p0->c[0] + p1->c[0] + p2->c[0]) / 3.0; cy = (p0->c[1] + p1->c[1] + p2->c[1]) / 3.0; cz = (ps0->bb + ps1->bb + ps2->bb) / 3.0; t.a[0] = shrink*(p0->c[0]-cx) + cx; t.a[1] = shrink*(p0->c[1]-cy) + cy; t.a[2] = shrink*(altcoef*ps0->bb-cz) + cz - 0.25*mesh->ztra; t.b[0] = shrink*(p1->c[0]-cx) + cx; t.b[1] = shrink*(p1->c[1]-cy) + cy; t.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t.c[0] = shrink*(p2->c[0]-cx) + cx; t.c[1] = shrink*(p2->c[1]-cy) + cy; t.c[2] = shrink*(altcoef*ps2->bb-cz) + cz - 0.25*mesh->ztra; /* compute normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( dd > 0.0 ) { dd = 1.0 / sqrt(dd); n[0] *= dd; n[1] *= dd; n[2] *= dd; } memcpy(t.na,n,3*sizeof(float)); memcpy(t.nb,n,3*sizeof(float)); memcpy(t.nc,n,3*sizeof(float)); t.va = ps0->bb; t.vb = ps1->bb; t.vc = ps2->bb; if ( mesh->typage == 2 ) cutTriangle(sc,t); else { if ( t.va < sc->iso.val[0] ) t.va = sc->iso.val[0]; else if ( t.va > sc->iso.val[MAXISO-1] ) t.va = sc->iso.val[MAXISO-1]; for (ia=0; ia<MAXISO-1; ia++) if ( t.va < sc->iso.val[ia] ) break; kc = (t.va-sc->iso.val[ia-1]) / (sc->iso.val[ia] - sc->iso.val[ia-1]); hsv[0] = sc->iso.col[ia-1]*(1.0-kc)+sc->iso.col[ia]*kc; hsvrgb(hsv,rgb); glColor4dv(rgb); glNormal3fv(t.na); glVertex3fv(t.a); glVertex3fv(t.b); glVertex3fv(t.c); /* add quads to sides (thanks to F. Lagoutiere) */ iadr = 3*(k-1)+1; adj = &mesh->adja[iadr]; voy = &mesh->voy[iadr]; if ( adj[0] && adj[0] < k ) { pt1 = &mesh->tria[ adj[0] ]; p3 = &mesh->point[ pt1->v[voy[0]] ]; ps1 = &mesh->sol[ adj[0] ]; cx = (p1->c[0] + p2->c[0] + p3->c[0]) / 3.0; cy = (p1->c[1] + p2->c[1] + p3->c[1]) / 3.0; cz = ps1->bb; memcpy(t1.a,t.b,3*sizeof(float)); memcpy(t1.b,t.c,3*sizeof(float)); memcpy(t1.c,t.b,3*sizeof(float)); t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.va = ps0->bb; t1.vb = ps0->bb; t1.vc = ps1->bb; memcpy(t1.na,nn,3*sizeof(float)); memcpy(t1.nb,nn,3*sizeof(float)); memcpy(t1.nc,nn,3*sizeof(float)); cutTriangle(sc,t1); memcpy(t1.a,t.c,3*sizeof(float)); memcpy(t1.b,t.c,3*sizeof(float)); memcpy(t1.c,t.b,3*sizeof(float)); t1.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.va = ps0->bb; t1.vb = ps1->bb; t1.vc = ps1->bb; memcpy(t1.na,nn,3*sizeof(float)); memcpy(t1.nb,nn,3*sizeof(float)); memcpy(t1.nc,nn,3*sizeof(float)); cutTriangle(sc,t1); } if ( adj[1] && adj[1] < k ) { pt1 = &mesh->tria[ adj[1] ]; p3 = &mesh->point[ pt1->v[voy[1]] ]; ps1 = &mesh->sol[ adj[1] ]; cx = (p0->c[0] + p2->c[0] + p3->c[0]) / 3.0; cy = (p0->c[1] + p2->c[1] + p3->c[1]) / 3.0; cz = ps1->bb; memcpy(t1.a,t.a,3*sizeof(float)); memcpy(t1.b,t.c,3*sizeof(float)); memcpy(t1.c,t.a,3*sizeof(float)); t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.va = ps0->bb; t1.vb = ps0->bb; t1.vc = ps1->bb; memcpy(t1.na,nn,3*sizeof(float)); memcpy(t1.nb,nn,3*sizeof(float)); memcpy(t1.nc,nn,3*sizeof(float)); cutTriangle(sc,t1); memcpy(t1.a,t.c,3*sizeof(float)); memcpy(t1.b,t.c,3*sizeof(float)); memcpy(t1.c,t.a,3*sizeof(float)); t1.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.va = ps0->bb; t1.vb = ps1->bb; t1.vc = ps1->bb; memcpy(t1.na,nn,3*sizeof(float)); memcpy(t1.nb,nn,3*sizeof(float)); memcpy(t1.nc,nn,3*sizeof(float)); cutTriangle(sc,t1); } if ( adj[2] && adj[2] < k ) { pt1 = &mesh->tria[ adj[2] ]; p3 = &mesh->point[ pt1->v[voy[2]] ]; ps1 = &mesh->sol[ adj[2] ]; cx = (p0->c[0] + p1->c[0] + p3->c[0]) / 3.0; cy = (p0->c[1] + p1->c[1] + p3->c[1]) / 3.0; cz = ps1->bb; memcpy(t1.a,t.a,3*sizeof(float)); memcpy(t1.b,t.b,3*sizeof(float)); memcpy(t1.c,t.a,3*sizeof(float)); t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.va = ps0->bb; t1.vb = ps0->bb; t1.vc = ps1->bb; memcpy(t1.na,nn,3*sizeof(float)); memcpy(t1.nb,nn,3*sizeof(float)); memcpy(t1.nc,nn,3*sizeof(float)); cutTriangle(sc,t1); memcpy(t1.a,t.b,3*sizeof(float)); memcpy(t1.b,t.b,3*sizeof(float)); memcpy(t1.c,t.a,3*sizeof(float)); t1.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.c[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t1.va = ps0->bb; t1.vb = ps1->bb; t1.vc = ps1->bb; memcpy(t1.na,nn,3*sizeof(float)); memcpy(t1.nb,nn,3*sizeof(float)); memcpy(t1.nc,nn,3*sizeof(float)); cutTriangle(sc,t1); } } k = pt->nxt; } } glEnd(); break; case LQuad: if ( ddebug ) printf("create quadrilateral list %d\n",mesh->nq); glBegin(GL_TRIANGLES); for (m=0; m<sc->par.nbmat; m++) { pm = &sc->material[m]; k = pm->depmat[LQuad]; if ( !k || pm->flag ) continue; while ( k != 0 ) { pq = &mesh->quad[k]; if ( !pq->v[0] ) { k = pq->nxt; continue; } p0 = &mesh->point[pq->v[0]]; p1 = &mesh->point[pq->v[1]]; p2 = &mesh->point[pq->v[2]]; p3 = &mesh->point[pq->v[3]]; if ( mesh->typage == 1 ) ps0 = ps1 = ps2 = ps3 = &mesh->sol[k]; else { ps0 = &mesh->sol[pq->v[0]]; ps1 = &mesh->sol[pq->v[1]]; ps2 = &mesh->sol[pq->v[2]]; ps3 = &mesh->sol[pq->v[3]]; } cx = 0.25 * (p0->c[0] + p1->c[0] + p2->c[0] + p3->c[0]); cy = 0.25 * (p0->c[1] + p1->c[1] + p2->c[1] + p3->c[1]); cz = 0.25 * (ps0->bb + ps1->bb + ps2->bb + ps3->bb); t.a[0] = t2.a[0] = shrink*(p0->c[0]-cx) + cx; t.a[1] = t2.a[1] = shrink*(p0->c[1]-cy) + cy; t.a[2] = t2.a[2] = shrink*(altcoef*ps0->bb-cz) + cz - 0.25*mesh->ztra; t.b[0] = shrink*(p1->c[0]-cx) + cx; t.b[1] = shrink*(p1->c[1]-cy) + cy; t.b[2] = shrink*(altcoef*ps1->bb-cz) + cz - 0.25*mesh->ztra; t.c[0] = t2.b[0] = shrink*(p2->c[0]-cx) + cx; t.c[1] = t2.b[1] = shrink*(p2->c[1]-cy) + cy; t.c[2] = t2.b[2] = shrink*(altcoef*ps2->bb-cz) + cz - 0.25*mesh->ztra; t2.c[0] = shrink*(p3->c[0]-cx) + cx; t2.c[1] = shrink*(p3->c[1]-cy) + cy; t2.c[2] = shrink*(altcoef*ps3->bb-cz) + cz - 0.25*mesh->ztra; /* compute normal */ ax = p1->c[0] - p0->c[0]; ay = p1->c[1] - p0->c[1]; az = p1->c[2] - p0->c[2]; bx = p2->c[0] - p0->c[0]; by = p2->c[1] - p0->c[1]; bz = p2->c[2] - p0->c[2]; n[0] = ay*bz - az*by; n[1] = az*bx - ax*bz; n[2] = ax*by - ay*bx; dd = n[0]*n[0] + n[1]*n[1] + n[2]*n[2]; if ( dd > 0.0f ) { dd = 1.0f / sqrt(dd); n[0] *= dd; n[1] *= dd; n[2] *= dd; } memcpy(t.na,n,3*sizeof(float)); memcpy(t.nb,n,3*sizeof(float)); memcpy(t.nc,n,3*sizeof(float)); memcpy(t2.na,n,3*sizeof(float)); memcpy(t2.nb,n,3*sizeof(float)); memcpy(t2.nc,n,3*sizeof(float)); t.va = t2.va = ps0->bb; t.vb = ps1->bb; t.vc = t2.vb = ps2->bb; t2.vc = ps3->bb; cutTriangle(sc,t); cutTriangle(sc,t2); k = pq->nxt; } } glEnd(); break; } glEndList(); return(dlist); }
unsigned int DisplayList::createIndex() { unsigned int gen = glGenLists(1); return gen; }
///////////////////////////////////////////////////////// // Render // void GEMglGenLists :: render(GemState *state) { GLuint i = glGenLists(range); outlet_float(m_outlet, static_cast<t_float>(i)); }
/* draw a simple diamond shape with OpenGL */ void draw_keyframe_shape(float x, float y, float xscale, float hsize, short sel, short key_type, short mode, float alpha) { static GLuint displist1 = 0; static GLuint displist2 = 0; /* initialize 2 display lists for diamond shape - one empty, one filled */ if (displist1 == 0) { displist1 = glGenLists(1); glNewList(displist1, GL_COMPILE); glBegin(GL_LINE_LOOP); glVertex2fv(_unit_diamond_shape[0]); glVertex2fv(_unit_diamond_shape[1]); glVertex2fv(_unit_diamond_shape[2]); glVertex2fv(_unit_diamond_shape[3]); glEnd(); glEndList(); } if (displist2 == 0) { displist2 = glGenLists(1); glNewList(displist2, GL_COMPILE); glBegin(GL_QUADS); glVertex2fv(_unit_diamond_shape[0]); glVertex2fv(_unit_diamond_shape[1]); glVertex2fv(_unit_diamond_shape[2]); glVertex2fv(_unit_diamond_shape[3]); glEnd(); glEndList(); } /* tweak size of keyframe shape according to type of keyframe * - 'proper' keyframes have key_type = 0, so get drawn at full size */ switch (key_type) { case BEZT_KEYTYPE_KEYFRAME: /* must be full size */ break; case BEZT_KEYTYPE_BREAKDOWN: /* slightly smaller than normal keyframe */ hsize *= 0.85f; break; case BEZT_KEYTYPE_MOVEHOLD: /* slightly smaller than normal keyframes (but by less than for breakdowns) */ //hsize *= 0.72f; hsize *= 0.95f; break; case BEZT_KEYTYPE_EXTREME: /* slightly larger */ hsize *= 1.2f; break; default: hsize -= 0.5f * key_type; break; } /* adjust view transform before starting */ glTranslatef(x, y, 0.0f); glScalef(1.0f / xscale * hsize, hsize, 1.0f); /* anti-aliased lines for more consistent appearance */ glEnable(GL_LINE_SMOOTH); /* draw! */ if (ELEM(mode, KEYFRAME_SHAPE_INSIDE, KEYFRAME_SHAPE_BOTH)) { float inner_col[4]; /* get interior colors from theme (for selected and unselected only) */ switch (key_type) { case BEZT_KEYTYPE_BREAKDOWN: /* bluish frames (default theme) */ { if (sel) UI_GetThemeColor4fv(TH_KEYTYPE_BREAKDOWN_SELECT, inner_col); else UI_GetThemeColor4fv(TH_KEYTYPE_BREAKDOWN, inner_col); break; } case BEZT_KEYTYPE_EXTREME: /* reddish frames (default theme) */ { if (sel) UI_GetThemeColor4fv(TH_KEYTYPE_EXTREME_SELECT, inner_col); else UI_GetThemeColor4fv(TH_KEYTYPE_EXTREME, inner_col); break; } case BEZT_KEYTYPE_JITTER: /* greenish frames (default theme) */ { if (sel) UI_GetThemeColor4fv(TH_KEYTYPE_JITTER_SELECT, inner_col); else UI_GetThemeColor4fv(TH_KEYTYPE_JITTER, inner_col); break; } case BEZT_KEYTYPE_MOVEHOLD: /* similar to traditional keyframes, but different... */ { /* XXX: Should these get their own theme options instead? */ if (sel) UI_GetThemeColorShade4fv(TH_STRIP_SELECT, 35, inner_col); else UI_GetThemeColorShade4fv(TH_STRIP, 50, inner_col); inner_col[3] = 1.0f; /* full opacity, to avoid problems with visual glitches */ break; } case BEZT_KEYTYPE_KEYFRAME: /* traditional yellowish frames (default theme) */ default: { if (sel) UI_GetThemeColor4fv(TH_KEYTYPE_KEYFRAME_SELECT, inner_col); else UI_GetThemeColor4fv(TH_KEYTYPE_KEYFRAME, inner_col); break; } } /* NOTE: we don't use the straight alpha from the theme, or else effects such as * graying out protected/muted channels doesn't work correctly! */ inner_col[3] *= alpha; glColor4fv(inner_col); /* draw the "filled in" interior poly now */ glCallList(displist2); } if (ELEM(mode, KEYFRAME_SHAPE_FRAME, KEYFRAME_SHAPE_BOTH)) { float border_col[4]; /* exterior - black frame */ if (sel) UI_GetThemeColor4fv(TH_KEYBORDER_SELECT, border_col); else UI_GetThemeColor4fv(TH_KEYBORDER, border_col); border_col[3] *= alpha; glColor4fv(border_col); glCallList(displist1); } glDisable(GL_LINE_SMOOTH); /* restore view transform */ glScalef(xscale / hsize, 1.0f / hsize, 1.0f); glTranslatef(-x, -y, 0.0f); }
/* Render one gear in the proper position, creating the gear's display list first if necessary. */ static void draw_gear (ModeInfo *mi, int which) { Bool wire_p = MI_IS_WIREFRAME(mi); pinion_configuration *pp = &pps[MI_SCREEN(mi)]; gear *g = pp->gears[which]; GLfloat th; Bool visible_p = (g->x + g->r + g->tooth_h >= pp->render_left && g->x - g->r - g->tooth_h <= pp->render_right); if (!visible_p && !debug_p) return; if (! g->dlist) { g->dlist = glGenLists (1); if (! g->dlist) { /* I don't know how many display lists a GL implementation is supposed to provide, but hopefully it's more than "a few hundred", or we'll be in trouble... */ check_gl_error ("glGenLists"); abort(); } glNewList (g->dlist, GL_COMPILE); g->polygons = draw_involute_gear (g, (wire_p && debug_p ? 2 : wire_p)); glEndList (); } glPushMatrix(); glTranslatef (g->x, g->y, g->z); if (g->motion_blur_p && !pp->button_down_p) { /* If we're in motion-blur mode, then draw the gear so that each frame rotates it by exactly one half tooth-width, so that it looks flickery around the edges. But, revert to the normal way when the mouse button is down lest the user see overlapping polygons. */ th = g->motion_blur_p * 180.0 / g->nteeth * (g->th > 0 ? 1 : -1); g->motion_blur_p++; } else th = g->th; glRotatef (th, 0, 0, 1); glPushName (g->id); if (! visible_p) mi->polygon_count += draw_involute_schematic (g, wire_p); else { glCallList (g->dlist); mi->polygon_count += g->polygons; } glPopName(); glPopMatrix(); }
void BuildGeometry (unsigned int surface, unsigned int colorScheme, unsigned int subdivisions, unsigned int xyRatio, GLuint * polyList, GLuint * lineList, GLuint * pointList) { long i,j, index; long maxI = subdivisions * xyRatio, maxJ = subdivisions; double u, v, delta=0.001; recVec p1,p2; recVec *vertexPos = NULL,*vertexNormal = NULL; recColor *vertexColor = NULL; recTexCoord *vertexTexCoord = NULL; // set valid surface and color scheme surface %= kSurfaces; colorScheme %= kColorSchemes; // delete existing list if (*polyList) glDeleteLists (*polyList, 1); if (*lineList) glDeleteLists (*lineList, 1); if (*pointList) glDeleteLists (*pointList, 1); *polyList = *lineList = *pointList = 0; if (surface == kCube) // build the standard color cube (disregard color, subdivisions, and xyRatio) BuildCube (polyList, lineList, pointList, colorScheme); else { // build buffers vertexPos = (recVec*) malloc ((maxI) * (maxJ) * sizeof (recVec)); if (vertexNormal) free (vertexNormal); vertexNormal = (recVec*) malloc ((maxI) * (maxJ) * sizeof (recVec)); if (vertexColor) free (vertexColor); vertexColor = (recColor*) malloc ((maxI) * (maxJ) * sizeof (recColor)); if (vertexTexCoord) free (vertexTexCoord); vertexTexCoord = (recTexCoord*) malloc ((maxI) * (maxJ) * sizeof (recTexCoord)); if (!vertexPos || !vertexNormal || !vertexColor || !vertexTexCoord) return; // build surface for (i = 0; i < maxI; i++) { for (j = 0; j < maxJ; j++) { index = i * maxJ + j; u = -PI + (i % maxI) * TWOPI / maxI; v = -PI + (j % maxJ) * TWOPI / maxJ; vertexPos[index] = Eval(u,v, surface); p1 = Eval(u + delta, v, surface); p2 = Eval(u, v + delta, surface); vertexNormal[index] = CalcNormal(vertexPos[index],p1,p2); vertexColor[index] = getColor(u, -PI, PI, colorScheme); vertexTexCoord[index].s = (float) i * 5.0f / (float) maxI; vertexTexCoord[index].t = (float) j * 1.0f/ (float) maxJ; } } *polyList = glGenLists (1); glNewList(*polyList, GL_COMPILE); for (i=0; i< maxI; i++) { glBegin(GL_TRIANGLE_STRIP); for (j = 0; j <= maxJ; j++) { index = (i % maxI) * maxJ + (j % maxJ); glColor3fv (&vertexColor[index].r); glNormal3fv (&vertexNormal[index].x); glTexCoord2fv (&vertexTexCoord[index].s); glVertex3fv (&vertexPos[index].x); index = ((i + 1) % maxI) * maxJ + (j % maxJ); glColor3fv (&vertexColor[index].r); glNormal3fv (&vertexNormal[index].x); glTexCoord2fv (&vertexTexCoord[index].s); glVertex3fv (&vertexPos[index].x); // index = ((i - 1) % maxI) * maxJ + (j % maxJ); } glEnd (); } glEndList (); *lineList = glGenLists (1); glNewList(*lineList, GL_COMPILE); for (i=0; i< maxI; i++) { glBegin(GL_LINE_STRIP); for (j = 0; j < maxJ; j++) { index = i * maxJ + j; glColor3fv (&vertexColor[index].r); glVertex3fv (&vertexPos[index].x); } index = i * maxJ + 0; glColor3fv (&vertexColor[index].r); glVertex3fv (&vertexPos[index].x); glEnd (); } for (j=0; j< maxJ; j++) { glBegin(GL_LINE_STRIP); for (i = 0; i < maxI; i++) { index = i * maxJ + j; glColor3fv (&vertexColor[index].r); glVertex3fv (&vertexPos[index].x); } index = 0 + j; glColor3fv (&vertexColor[index].r); glVertex3fv (&vertexPos[index].x); glEnd (); } glEndList (); *pointList = glGenLists (1); glNewList(*pointList, GL_COMPILE); glBegin(GL_POINTS); for (i=0; i< maxI; i++) { for (j = 0; j < maxJ; j++) { index = i * maxJ + j; glColor3fv (&vertexColor[index].r); glVertex3fv (&vertexPos[index].x); } } glEnd (); glEndList (); free (vertexPos); free (vertexNormal); free (vertexColor); } }
GLint makebclockhousing(void){ GLuint dlistindex; GLUquadricObj * pole; int iterator; GLuint banklistindex; GLuint connectlistindex; GLuint secconnectlistindex; GLfloat steel_ambient[] = {0.19225, 0.19225, 0.19225, 1.0}; GLfloat steel_diffuse[] = {0.50754, 0.50754, 0.50754, 1.0}; GLfloat steel_specular[] = {0.508273, 0.508273, 0.508273, 1.0}; GLfloat steel_emission[] = {0.0, 0.0, 0.0, 1.0}; GLfloat steel_shininess = 0.4; banklistindex = makebankdlist(); connectlistindex = makeconnectdlist(); secconnectlistindex = makesecconnectdlist(); pole = gluNewQuadric(); gluQuadricCallback(pole, GLU_ERROR, (_GLUfuncptr)errorCallback); gluQuadricDrawStyle(pole, GLU_FILL); gluQuadricNormals(pole, GLU_SMOOTH); dlistindex = glGenLists(1); glNewList(dlistindex, GL_COMPILE); glMaterialfv(GL_FRONT, GL_AMBIENT, steel_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, steel_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, steel_specular); glMaterialfv(GL_FRONT, GL_EMISSION, steel_emission); glMaterialf(GL_FRONT, GL_SHININESS, steel_shininess * 128.0); /* draw banks, including seconds */ glPushMatrix(); glTranslatef(0.0, -10., 0.); for (iterator = 0; iterator < 4; iterator++) { glCallList(banklistindex); glTranslatef(0.0, 5.0, 0.); } glTranslatef(0.0, 0., -1.0); gluCylinder(pole, 2.5, 2.5, 2, 24, 16); glTranslatef( 0.0, 0.0, 2.0); gluDisk(pole, 0, 2.5, 24, 16); glPopMatrix(); /* draw connectors */ glPushMatrix(); glTranslatef(0., -7.5, 0.); for (iterator = 0; iterator < 3; iterator++) { glPushMatrix(); glTranslatef(-4.5, 0., 0.); glCallList(connectlistindex); glPopMatrix(); glPushMatrix(); glTranslatef(4.5, 0., 0.); glCallList(connectlistindex); glPopMatrix(); glTranslatef(0., 5.0, 0.); } glTranslatef(0., -0.15, 0.); glCallList(secconnectlistindex); glPopMatrix(); /* draw pole */ glPushMatrix(); glRotatef(90.0, 1.0, 0.0, 0.0); glTranslatef(0.0, 0.0, 12.0); gluCylinder(pole, 0.75, 0.75, 20, 16, 12); glPopMatrix(); glEndList(); handleGLerrors("makebclockhousing"); return dlistindex; }
////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering // context. void SetupRC() { M3DVector3f vPoints[3] = {{ 0.0f, -0.4f, 0.0f }, { 10.0f, -0.4f, 0.0f }, { 5.0f, -0.4f, -5.0f }}; int iSphere; int i; // Grayish background glClearColor(fLowLight[0], fLowLight[1], fLowLight[2], fLowLight[3]); // Clear stencil buffer with zero, increment by one whenever anybody // draws into it. When stencil function is enabled, only write where // stencil value is zero. This prevents the transparent shadow from drawing // over itself glStencilOp(GL_INCR, GL_INCR, GL_INCR); glClearStencil(0); glStencilFunc(GL_EQUAL, 0x0, 0x01); // Cull backs of polygons glCullFace(GL_BACK); glFrontFace(GL_CCW); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glEnable(GL_MULTISAMPLE_ARB); // Setup light parameters glLightModelfv(GL_LIGHT_MODEL_AMBIENT, fNoLight); glLightfv(GL_LIGHT0, GL_AMBIENT, fLowLight); glLightfv(GL_LIGHT0, GL_DIFFUSE, fBrightLight); glLightfv(GL_LIGHT0, GL_SPECULAR, fBrightLight); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR); // Calculate shadow matrix M3DVector4f pPlane; m3dGetPlaneEquation(pPlane, vPoints[0], vPoints[1], vPoints[2]); m3dMakePlanarShadowMatrix(mShadowMatrix, pPlane, fLightPos); // Mostly use material tracking glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT, GL_SPECULAR, fBrightLight); glMateriali(GL_FRONT, GL_SHININESS, 128); // Randomly place the sphere inhabitants for(iSphere = 0; iSphere < NUM_SPHERES; iSphere++) { // Pick a random location between -20 and 20 at .1 increments spheres[iSphere].SetOrigin(((float)((rand() % 400) - 200) * 0.1f), 0.0, (float)((rand() % 400) - 200) * 0.1f); } // Set up texture maps glEnable(GL_TEXTURE_2D); glGenTextures(NUM_TEXTURES, textureObjects); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); for(i = 0; i < NUM_TEXTURES; i++) { GLbyte *pBytes; GLint iWidth, iHeight, iComponents; GLenum eFormat; glBindTexture(GL_TEXTURE_2D, textureObjects[i]); // Load this texture map pBytes = gltLoadTGA(szTextureFiles[i], &iWidth, &iHeight, &iComponents, &eFormat); gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); free(pBytes); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); } // Create display lists groundList = glGenLists(3); sphereList = groundList + 1; torusList = sphereList + 1; // Create sphere display list glNewList(sphereList, GL_COMPILE); gltDrawSphere(0.1f, 40, 20); glEndList(); // Create torus display list glNewList(torusList, GL_COMPILE); gltDrawTorus(0.35, 0.15, 61, 37); glEndList(); // Create the ground display list glNewList(groundList, GL_COMPILE); DrawGround(); glEndList(); }