示例#1
0
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();
}
示例#2
0
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++);
	}
}
示例#4
0
/* 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);
}
示例#6
0
	/* CONSTRUCTORS */
	FFTButton::FFTButton(const Point2f &position, float width, float height) :
		Button(position, width, height)
	{
		fftButtonDirty = true;
		fftButtonDisplayList = glGenLists(1);
	}
示例#7
0
/* 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);
}
示例#8
0
文件: view.cpp 项目: barche/carve
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;
}
示例#9
0
// 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();
    }
示例#10
0
文件: isosurf.c 项目: aosm/X11apps
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;
   }
}
示例#11
0
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;
}
示例#12
0
GridEditor::DataItem::DataItem(void)
	:influenceSphereDisplayListId(glGenLists(1)),
	 domainBoxDisplayListId(glGenLists(1))
	{
	}
示例#13
0
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();
}
示例#14
0
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 ();
	}
}
示例#15
0
文件: ccOctree.cpp 项目: jebd/trunk
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();
}
示例#16
0
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;
}
示例#17
0
文件: offset.cpp 项目: dbc/pyPolyCSG
  TestScene(int argc, char **argv, int n_dlist) : Scene(argc, argv) {
    draw_list_base = glGenLists(n_dlist);

    draw_flags.resize(n_dlist, false);
  }
示例#18
0
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);
}
示例#19
0
/* 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);
}
示例#20
0
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();
		}
	}
}
示例#21
0
/* 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);
}
示例#22
0
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);
}
示例#23
0
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);
}
示例#24
0
		unsigned int DisplayList::createIndex()
		{
			unsigned int gen = glGenLists(1);
			return gen;
		}
示例#25
0
/////////////////////////////////////////////////////////
// Render
//
void GEMglGenLists :: render(GemState *state) {
  GLuint i = glGenLists(range);
  outlet_float(m_outlet, static_cast<t_float>(i));
}
示例#26
0
/* 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);
}
示例#27
0
/* 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();
}
示例#28
0
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);
	}
}
示例#29
0
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;


}
示例#30
0
//////////////////////////////////////////////////////////////////
// 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();
    }